Update year range in copyright notice of all files.
[external/binutils.git] / bfd / elf64-alpha.c
1 /* Alpha specific support for 64-bit ELF
2    Copyright (C) 1996-2017 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 void
1104 elf64_alpha_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 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 (_("%B: unrecognised Alpha reloc number: %d"),
1113                           abfd, r_type);
1114       bfd_set_error (bfd_error_bad_value);
1115       r_type = R_ALPHA_NONE;
1116     }
1117   cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1118 }
1119
1120 /* These two relocations create a two-word entry in the got.  */
1121 #define alpha_got_entry_size(r_type) \
1122   (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1123
1124 /* This is PT_TLS segment p_vaddr.  */
1125 #define alpha_get_dtprel_base(info) \
1126   (elf_hash_table (info)->tls_sec->vma)
1127
1128 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1129    is assigned offset round(16, PT_TLS p_align).  */
1130 #define alpha_get_tprel_base(info) \
1131   (elf_hash_table (info)->tls_sec->vma                                  \
1132    - align_power ((bfd_vma) 16,                                         \
1133                   elf_hash_table (info)->tls_sec->alignment_power))
1134 \f
1135 /* Handle an Alpha specific section when reading an object file.  This
1136    is called when bfd_section_from_shdr finds a section with an unknown
1137    type.
1138    FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1139    how to.  */
1140
1141 static bfd_boolean
1142 elf64_alpha_section_from_shdr (bfd *abfd,
1143                                Elf_Internal_Shdr *hdr,
1144                                const char *name,
1145                                int shindex)
1146 {
1147   asection *newsect;
1148
1149   /* There ought to be a place to keep ELF backend specific flags, but
1150      at the moment there isn't one.  We just keep track of the
1151      sections by their name, instead.  Fortunately, the ABI gives
1152      suggested names for all the MIPS specific sections, so we will
1153      probably get away with this.  */
1154   switch (hdr->sh_type)
1155     {
1156     case SHT_ALPHA_DEBUG:
1157       if (strcmp (name, ".mdebug") != 0)
1158         return FALSE;
1159       break;
1160     default:
1161       return FALSE;
1162     }
1163
1164   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1165     return FALSE;
1166   newsect = hdr->bfd_section;
1167
1168   if (hdr->sh_type == SHT_ALPHA_DEBUG)
1169     {
1170       if (! bfd_set_section_flags (abfd, newsect,
1171                                    (bfd_get_section_flags (abfd, newsect)
1172                                     | SEC_DEBUGGING)))
1173         return FALSE;
1174     }
1175
1176   return TRUE;
1177 }
1178
1179 /* Convert Alpha specific section flags to bfd internal section flags.  */
1180
1181 static bfd_boolean
1182 elf64_alpha_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
1183 {
1184   if (hdr->sh_flags & SHF_ALPHA_GPREL)
1185     *flags |= SEC_SMALL_DATA;
1186
1187   return TRUE;
1188 }
1189
1190 /* Set the correct type for an Alpha ELF section.  We do this by the
1191    section name, which is a hack, but ought to work.  */
1192
1193 static bfd_boolean
1194 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1195 {
1196   register const char *name;
1197
1198   name = bfd_get_section_name (abfd, sec);
1199
1200   if (strcmp (name, ".mdebug") == 0)
1201     {
1202       hdr->sh_type = SHT_ALPHA_DEBUG;
1203       /* In a shared object on Irix 5.3, the .mdebug section has an
1204          entsize of 0.  FIXME: Does this matter?  */
1205       if ((abfd->flags & DYNAMIC) != 0 )
1206         hdr->sh_entsize = 0;
1207       else
1208         hdr->sh_entsize = 1;
1209     }
1210   else if ((sec->flags & SEC_SMALL_DATA)
1211            || strcmp (name, ".sdata") == 0
1212            || strcmp (name, ".sbss") == 0
1213            || strcmp (name, ".lit4") == 0
1214            || strcmp (name, ".lit8") == 0)
1215     hdr->sh_flags |= SHF_ALPHA_GPREL;
1216
1217   return TRUE;
1218 }
1219
1220 /* Hook called by the linker routine which adds symbols from an object
1221    file.  We use it to put .comm items in .sbss, and not .bss.  */
1222
1223 static bfd_boolean
1224 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1225                              Elf_Internal_Sym *sym,
1226                              const char **namep ATTRIBUTE_UNUSED,
1227                              flagword *flagsp ATTRIBUTE_UNUSED,
1228                              asection **secp, bfd_vma *valp)
1229 {
1230   if (sym->st_shndx == SHN_COMMON
1231       && !bfd_link_relocatable (info)
1232       && sym->st_size <= elf_gp_size (abfd))
1233     {
1234       /* Common symbols less than or equal to -G nn bytes are
1235          automatically put into .sbss.  */
1236
1237       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1238
1239       if (scomm == NULL)
1240         {
1241           scomm = bfd_make_section_with_flags (abfd, ".scommon",
1242                                                (SEC_ALLOC
1243                                                 | SEC_IS_COMMON
1244                                                 | SEC_LINKER_CREATED));
1245           if (scomm == NULL)
1246             return FALSE;
1247         }
1248
1249       *secp = scomm;
1250       *valp = sym->st_size;
1251     }
1252
1253   return TRUE;
1254 }
1255
1256 /* Create the .got section.  */
1257
1258 static bfd_boolean
1259 elf64_alpha_create_got_section (bfd *abfd,
1260                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1261 {
1262   flagword flags;
1263   asection *s;
1264
1265   if (! is_alpha_elf (abfd))
1266     return FALSE;
1267
1268   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1269            | SEC_LINKER_CREATED);
1270   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1271   if (s == NULL
1272       || !bfd_set_section_alignment (abfd, s, 3))
1273     return FALSE;
1274
1275   alpha_elf_tdata (abfd)->got = s;
1276
1277   /* Make sure the object's gotobj is set to itself so that we default
1278      to every object with its own .got.  We'll merge .gots later once
1279      we've collected each object's info.  */
1280   alpha_elf_tdata (abfd)->gotobj = abfd;
1281
1282   return TRUE;
1283 }
1284
1285 /* Create all the dynamic sections.  */
1286
1287 static bfd_boolean
1288 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1289 {
1290   asection *s;
1291   flagword flags;
1292   struct elf_link_hash_entry *h;
1293
1294   if (! is_alpha_elf (abfd))
1295     return FALSE;
1296
1297   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
1298
1299   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1300            | SEC_LINKER_CREATED
1301            | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1302   s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1303   elf_hash_table (info)->splt = s;
1304   if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4))
1305     return FALSE;
1306
1307   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1308      .plt section.  */
1309   h = _bfd_elf_define_linkage_sym (abfd, info, s,
1310                                    "_PROCEDURE_LINKAGE_TABLE_");
1311   elf_hash_table (info)->hplt = h;
1312   if (h == NULL)
1313     return FALSE;
1314
1315   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1316            | SEC_LINKER_CREATED | SEC_READONLY);
1317   s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1318   elf_hash_table (info)->srelplt = s;
1319   if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1320     return FALSE;
1321
1322   if (elf64_alpha_use_secureplt)
1323     {
1324       flags = SEC_ALLOC | SEC_LINKER_CREATED;
1325       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1326       elf_hash_table (info)->sgotplt = s;
1327       if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1328         return FALSE;
1329     }
1330
1331   /* We may or may not have created a .got section for this object, but
1332      we definitely havn't done the rest of the work.  */
1333
1334   if (alpha_elf_tdata(abfd)->gotobj == NULL)
1335     {
1336       if (!elf64_alpha_create_got_section (abfd, info))
1337         return FALSE;
1338     }
1339
1340   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1341            | SEC_LINKER_CREATED | SEC_READONLY);
1342   s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1343   elf_hash_table (info)->srelgot = s;
1344   if (s == NULL
1345       || !bfd_set_section_alignment (abfd, s, 3))
1346     return FALSE;
1347
1348   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1349      dynobj's .got section.  We don't do this in the linker script
1350      because we don't want to define the symbol if we are not creating
1351      a global offset table.  */
1352   h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1353                                    "_GLOBAL_OFFSET_TABLE_");
1354   elf_hash_table (info)->hgot = h;
1355   if (h == NULL)
1356     return FALSE;
1357
1358   return TRUE;
1359 }
1360 \f
1361 /* Read ECOFF debugging information from a .mdebug section into a
1362    ecoff_debug_info structure.  */
1363
1364 static bfd_boolean
1365 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1366                              struct ecoff_debug_info *debug)
1367 {
1368   HDRR *symhdr;
1369   const struct ecoff_debug_swap *swap;
1370   char *ext_hdr = NULL;
1371
1372   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1373   memset (debug, 0, sizeof (*debug));
1374
1375   ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1376   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1377     goto error_return;
1378
1379   if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1380                                   swap->external_hdr_size))
1381     goto error_return;
1382
1383   symhdr = &debug->symbolic_header;
1384   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1385
1386   /* The symbolic header contains absolute file offsets and sizes to
1387      read.  */
1388 #define READ(ptr, offset, count, size, type)                            \
1389   if (symhdr->count == 0)                                               \
1390     debug->ptr = NULL;                                                  \
1391   else                                                                  \
1392     {                                                                   \
1393       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1394       debug->ptr = (type) bfd_malloc (amt);                             \
1395       if (debug->ptr == NULL)                                           \
1396         goto error_return;                                              \
1397       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
1398           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1399         goto error_return;                                              \
1400     }
1401
1402   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1403   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1404   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1405   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1406   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1407   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1408         union aux_ext *);
1409   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1410   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1411   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1412   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1413   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1414 #undef READ
1415
1416   debug->fdr = NULL;
1417
1418   return TRUE;
1419
1420  error_return:
1421   if (ext_hdr != NULL)
1422     free (ext_hdr);
1423   if (debug->line != NULL)
1424     free (debug->line);
1425   if (debug->external_dnr != NULL)
1426     free (debug->external_dnr);
1427   if (debug->external_pdr != NULL)
1428     free (debug->external_pdr);
1429   if (debug->external_sym != NULL)
1430     free (debug->external_sym);
1431   if (debug->external_opt != NULL)
1432     free (debug->external_opt);
1433   if (debug->external_aux != NULL)
1434     free (debug->external_aux);
1435   if (debug->ss != NULL)
1436     free (debug->ss);
1437   if (debug->ssext != NULL)
1438     free (debug->ssext);
1439   if (debug->external_fdr != NULL)
1440     free (debug->external_fdr);
1441   if (debug->external_rfd != NULL)
1442     free (debug->external_rfd);
1443   if (debug->external_ext != NULL)
1444     free (debug->external_ext);
1445   return FALSE;
1446 }
1447
1448 /* Alpha ELF local labels start with '$'.  */
1449
1450 static bfd_boolean
1451 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1452 {
1453   return name[0] == '$';
1454 }
1455
1456 static bfd_boolean
1457 elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
1458                                asection *section, bfd_vma offset,
1459                                const char **filename_ptr,
1460                                const char **functionname_ptr,
1461                                unsigned int *line_ptr,
1462                                unsigned int *discriminator_ptr)
1463 {
1464   asection *msec;
1465
1466   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
1467                                      filename_ptr, functionname_ptr,
1468                                      line_ptr, discriminator_ptr,
1469                                      dwarf_debug_sections, 0,
1470                                      &elf_tdata (abfd)->dwarf2_find_line_info))
1471     return TRUE;
1472
1473   msec = bfd_get_section_by_name (abfd, ".mdebug");
1474   if (msec != NULL)
1475     {
1476       flagword origflags;
1477       struct alpha_elf_find_line *fi;
1478       const struct ecoff_debug_swap * const swap =
1479         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1480
1481       /* If we are called during a link, alpha_elf_final_link may have
1482          cleared the SEC_HAS_CONTENTS field.  We force it back on here
1483          if appropriate (which it normally will be).  */
1484       origflags = msec->flags;
1485       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1486         msec->flags |= SEC_HAS_CONTENTS;
1487
1488       fi = alpha_elf_tdata (abfd)->find_line_info;
1489       if (fi == NULL)
1490         {
1491           bfd_size_type external_fdr_size;
1492           char *fraw_src;
1493           char *fraw_end;
1494           struct fdr *fdr_ptr;
1495           bfd_size_type amt = sizeof (struct alpha_elf_find_line);
1496
1497           fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt);
1498           if (fi == NULL)
1499             {
1500               msec->flags = origflags;
1501               return FALSE;
1502             }
1503
1504           if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1505             {
1506               msec->flags = origflags;
1507               return FALSE;
1508             }
1509
1510           /* Swap in the FDR information.  */
1511           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1512           fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1513           if (fi->d.fdr == NULL)
1514             {
1515               msec->flags = origflags;
1516               return FALSE;
1517             }
1518           external_fdr_size = swap->external_fdr_size;
1519           fdr_ptr = fi->d.fdr;
1520           fraw_src = (char *) fi->d.external_fdr;
1521           fraw_end = (fraw_src
1522                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
1523           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1524             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
1525
1526           alpha_elf_tdata (abfd)->find_line_info = fi;
1527
1528           /* Note that we don't bother to ever free this information.
1529              find_nearest_line is either called all the time, as in
1530              objdump -l, so the information should be saved, or it is
1531              rarely called, as in ld error messages, so the memory
1532              wasted is unimportant.  Still, it would probably be a
1533              good idea for free_cached_info to throw it away.  */
1534         }
1535
1536       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1537                                   &fi->i, filename_ptr, functionname_ptr,
1538                                   line_ptr))
1539         {
1540           msec->flags = origflags;
1541           return TRUE;
1542         }
1543
1544       msec->flags = origflags;
1545     }
1546
1547   /* Fall back on the generic ELF find_nearest_line routine.  */
1548
1549   return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
1550                                      filename_ptr, functionname_ptr,
1551                                      line_ptr, discriminator_ptr);
1552 }
1553 \f
1554 /* Structure used to pass information to alpha_elf_output_extsym.  */
1555
1556 struct extsym_info
1557 {
1558   bfd *abfd;
1559   struct bfd_link_info *info;
1560   struct ecoff_debug_info *debug;
1561   const struct ecoff_debug_swap *swap;
1562   bfd_boolean failed;
1563 };
1564
1565 static bfd_boolean
1566 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
1567 {
1568   struct extsym_info *einfo = (struct extsym_info *) data;
1569   bfd_boolean strip;
1570   asection *sec, *output_section;
1571
1572   if (h->root.indx == -2)
1573     strip = FALSE;
1574   else if ((h->root.def_dynamic
1575             || h->root.ref_dynamic
1576             || h->root.root.type == bfd_link_hash_new)
1577            && !h->root.def_regular
1578            && !h->root.ref_regular)
1579     strip = TRUE;
1580   else if (einfo->info->strip == strip_all
1581            || (einfo->info->strip == strip_some
1582                && bfd_hash_lookup (einfo->info->keep_hash,
1583                                    h->root.root.root.string,
1584                                    FALSE, FALSE) == NULL))
1585     strip = TRUE;
1586   else
1587     strip = FALSE;
1588
1589   if (strip)
1590     return TRUE;
1591
1592   if (h->esym.ifd == -2)
1593     {
1594       h->esym.jmptbl = 0;
1595       h->esym.cobol_main = 0;
1596       h->esym.weakext = 0;
1597       h->esym.reserved = 0;
1598       h->esym.ifd = ifdNil;
1599       h->esym.asym.value = 0;
1600       h->esym.asym.st = stGlobal;
1601
1602       if (h->root.root.type != bfd_link_hash_defined
1603           && h->root.root.type != bfd_link_hash_defweak)
1604         h->esym.asym.sc = scAbs;
1605       else
1606         {
1607           const char *name;
1608
1609           sec = h->root.root.u.def.section;
1610           output_section = sec->output_section;
1611
1612           /* When making a shared library and symbol h is the one from
1613              the another shared library, OUTPUT_SECTION may be null.  */
1614           if (output_section == NULL)
1615             h->esym.asym.sc = scUndefined;
1616           else
1617             {
1618               name = bfd_section_name (output_section->owner, output_section);
1619
1620               if (strcmp (name, ".text") == 0)
1621                 h->esym.asym.sc = scText;
1622               else if (strcmp (name, ".data") == 0)
1623                 h->esym.asym.sc = scData;
1624               else if (strcmp (name, ".sdata") == 0)
1625                 h->esym.asym.sc = scSData;
1626               else if (strcmp (name, ".rodata") == 0
1627                        || strcmp (name, ".rdata") == 0)
1628                 h->esym.asym.sc = scRData;
1629               else if (strcmp (name, ".bss") == 0)
1630                 h->esym.asym.sc = scBss;
1631               else if (strcmp (name, ".sbss") == 0)
1632                 h->esym.asym.sc = scSBss;
1633               else if (strcmp (name, ".init") == 0)
1634                 h->esym.asym.sc = scInit;
1635               else if (strcmp (name, ".fini") == 0)
1636                 h->esym.asym.sc = scFini;
1637               else
1638                 h->esym.asym.sc = scAbs;
1639             }
1640         }
1641
1642       h->esym.asym.reserved = 0;
1643       h->esym.asym.index = indexNil;
1644     }
1645
1646   if (h->root.root.type == bfd_link_hash_common)
1647     h->esym.asym.value = h->root.root.u.c.size;
1648   else if (h->root.root.type == bfd_link_hash_defined
1649            || h->root.root.type == bfd_link_hash_defweak)
1650     {
1651       if (h->esym.asym.sc == scCommon)
1652         h->esym.asym.sc = scBss;
1653       else if (h->esym.asym.sc == scSCommon)
1654         h->esym.asym.sc = scSBss;
1655
1656       sec = h->root.root.u.def.section;
1657       output_section = sec->output_section;
1658       if (output_section != NULL)
1659         h->esym.asym.value = (h->root.root.u.def.value
1660                               + sec->output_offset
1661                               + output_section->vma);
1662       else
1663         h->esym.asym.value = 0;
1664     }
1665
1666   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1667                                       h->root.root.root.string,
1668                                       &h->esym))
1669     {
1670       einfo->failed = TRUE;
1671       return FALSE;
1672     }
1673
1674   return TRUE;
1675 }
1676 \f
1677 /* Search for and possibly create a got entry.  */
1678
1679 static struct alpha_elf_got_entry *
1680 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1681                unsigned long r_type, unsigned long r_symndx,
1682                bfd_vma r_addend)
1683 {
1684   struct alpha_elf_got_entry *gotent;
1685   struct alpha_elf_got_entry **slot;
1686
1687   if (h)
1688     slot = &h->got_entries;
1689   else
1690     {
1691       /* This is a local .got entry -- record for merge.  */
1692
1693       struct alpha_elf_got_entry **local_got_entries;
1694
1695       local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1696       if (!local_got_entries)
1697         {
1698           bfd_size_type size;
1699           Elf_Internal_Shdr *symtab_hdr;
1700
1701           symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1702           size = symtab_hdr->sh_info;
1703           size *= sizeof (struct alpha_elf_got_entry *);
1704
1705           local_got_entries
1706             = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1707           if (!local_got_entries)
1708             return NULL;
1709
1710           alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1711         }
1712
1713       slot = &local_got_entries[r_symndx];
1714     }
1715
1716   for (gotent = *slot; gotent ; gotent = gotent->next)
1717     if (gotent->gotobj == abfd
1718         && gotent->reloc_type == r_type
1719         && gotent->addend == r_addend)
1720       break;
1721
1722   if (!gotent)
1723     {
1724       int entry_size;
1725       bfd_size_type amt;
1726
1727       amt = sizeof (struct alpha_elf_got_entry);
1728       gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1729       if (!gotent)
1730         return NULL;
1731
1732       gotent->gotobj = abfd;
1733       gotent->addend = r_addend;
1734       gotent->got_offset = -1;
1735       gotent->plt_offset = -1;
1736       gotent->use_count = 1;
1737       gotent->reloc_type = r_type;
1738       gotent->reloc_done = 0;
1739       gotent->reloc_xlated = 0;
1740
1741       gotent->next = *slot;
1742       *slot = gotent;
1743
1744       entry_size = alpha_got_entry_size (r_type);
1745       alpha_elf_tdata (abfd)->total_got_size += entry_size;
1746       if (!h)
1747         alpha_elf_tdata(abfd)->local_got_size += entry_size;
1748     }
1749   else
1750     gotent->use_count += 1;
1751
1752   return gotent;
1753 }
1754
1755 static bfd_boolean
1756 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1757 {
1758   return ((ah->root.type == STT_FUNC
1759           || ah->root.root.type == bfd_link_hash_undefweak
1760           || ah->root.root.type == bfd_link_hash_undefined)
1761           && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1762           && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1763 }
1764
1765 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
1766    Don't do so for code sections.  We want to keep ordering of LITERAL/LITUSE
1767    as is.  On the other hand, elf-eh-frame.c processing requires .eh_frame
1768    relocs to be sorted.  */
1769
1770 static bfd_boolean
1771 elf64_alpha_sort_relocs_p (asection *sec)
1772 {
1773   return (sec->flags & SEC_CODE) == 0;
1774 }
1775
1776
1777 /* Handle dynamic relocations when doing an Alpha ELF link.  */
1778
1779 static bfd_boolean
1780 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1781                           asection *sec, const Elf_Internal_Rela *relocs)
1782 {
1783   bfd *dynobj;
1784   asection *sreloc;
1785   Elf_Internal_Shdr *symtab_hdr;
1786   struct alpha_elf_link_hash_entry **sym_hashes;
1787   const Elf_Internal_Rela *rel, *relend;
1788   bfd_size_type amt;
1789
1790   if (bfd_link_relocatable (info))
1791     return TRUE;
1792
1793   /* Don't do anything special with non-loaded, non-alloced sections.
1794      In particular, any relocs in such sections should not affect GOT
1795      and PLT reference counting (ie. we don't allow them to create GOT
1796      or PLT entries), there's no possibility or desire to optimize TLS
1797      relocs, and there's not much point in propagating relocs to shared
1798      libs that the dynamic linker won't relocate.  */
1799   if ((sec->flags & SEC_ALLOC) == 0)
1800     return TRUE;
1801
1802   BFD_ASSERT (is_alpha_elf (abfd));
1803
1804   dynobj = elf_hash_table (info)->dynobj;
1805   if (dynobj == NULL)
1806     elf_hash_table (info)->dynobj = dynobj = abfd;
1807
1808   sreloc = NULL;
1809   symtab_hdr = &elf_symtab_hdr (abfd);
1810   sym_hashes = alpha_elf_sym_hashes (abfd);
1811
1812   relend = relocs + sec->reloc_count;
1813   for (rel = relocs; rel < relend; ++rel)
1814     {
1815       enum {
1816         NEED_GOT = 1,
1817         NEED_GOT_ENTRY = 2,
1818         NEED_DYNREL = 4
1819       };
1820
1821       unsigned long r_symndx, r_type;
1822       struct alpha_elf_link_hash_entry *h;
1823       unsigned int gotent_flags;
1824       bfd_boolean maybe_dynamic;
1825       unsigned int need;
1826       bfd_vma addend;
1827
1828       r_symndx = ELF64_R_SYM (rel->r_info);
1829       if (r_symndx < symtab_hdr->sh_info)
1830         h = NULL;
1831       else
1832         {
1833           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1834
1835           while (h->root.root.type == bfd_link_hash_indirect
1836                  || h->root.root.type == bfd_link_hash_warning)
1837             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1838
1839           /* PR15323, ref flags aren't set for references in the same
1840              object.  */
1841           h->root.root.non_ir_ref = 1;
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 /* Update the got entry reference counts for the section being removed.  */
2044
2045 static bfd_boolean
2046 elf64_alpha_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2047                            asection *sec, const Elf_Internal_Rela *relocs)
2048 {
2049   Elf_Internal_Shdr *symtab_hdr;
2050   struct alpha_elf_link_hash_entry **sym_hashes;
2051   const Elf_Internal_Rela *rel, *relend;
2052
2053   if (bfd_link_relocatable (info))
2054     return TRUE;
2055
2056   symtab_hdr = &elf_symtab_hdr (abfd);
2057   sym_hashes = alpha_elf_sym_hashes (abfd);
2058
2059   relend = relocs + sec->reloc_count;
2060   for (rel = relocs; rel < relend; rel++)
2061     {
2062       unsigned long r_symndx, r_type;
2063       struct alpha_elf_link_hash_entry *h = NULL;
2064       struct alpha_elf_got_entry *gotent;
2065
2066       r_symndx = ELF64_R_SYM (rel->r_info);
2067       if (r_symndx >= symtab_hdr->sh_info)
2068         {
2069           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2070           while (h->root.root.type == bfd_link_hash_indirect
2071                  || h->root.root.type == bfd_link_hash_warning)
2072             h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2073         }
2074
2075       r_type = ELF64_R_TYPE (rel->r_info);
2076       switch (r_type)
2077         {
2078         case R_ALPHA_LITERAL:
2079           /* ??? Ignore re-computation of gotent_flags.  We're not
2080              carrying a use-count for each bit in that mask.  */
2081
2082         case R_ALPHA_TLSGD:
2083         case R_ALPHA_GOTDTPREL:
2084         case R_ALPHA_GOTTPREL:
2085           /* Fetch the got entry from the tables.  */
2086           gotent = get_got_entry (abfd, h, r_type, r_symndx, rel->r_addend);
2087
2088           /* The got entry *must* exist, since we should have created it
2089              before during check_relocs.  Also note that get_got_entry
2090              assumed this was going to be another use, and so incremented
2091              the use count again.  Thus the use count must be at least the
2092              one real use and the "use" we just added.  */
2093           if (gotent == NULL || gotent->use_count < 2)
2094             {
2095               abort ();
2096               return FALSE;
2097             }
2098           gotent->use_count -= 2;
2099           break;
2100
2101         default:
2102           break;
2103         }
2104     }
2105
2106   return TRUE;
2107 }
2108
2109 /* Adjust a symbol defined by a dynamic object and referenced by a
2110    regular object.  The current definition is in some section of the
2111    dynamic object, but we're not including those sections.  We have to
2112    change the definition to something the rest of the link can
2113    understand.  */
2114
2115 static bfd_boolean
2116 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2117                                    struct elf_link_hash_entry *h)
2118 {
2119   bfd *dynobj;
2120   asection *s;
2121   struct alpha_elf_link_hash_entry *ah;
2122
2123   dynobj = elf_hash_table(info)->dynobj;
2124   ah = (struct alpha_elf_link_hash_entry *)h;
2125
2126   /* Now that we've seen all of the input symbols, finalize our decision
2127      about whether this symbol should get a .plt entry.  Irritatingly, it
2128      is common for folk to leave undefined symbols in shared libraries,
2129      and they still expect lazy binding; accept undefined symbols in lieu
2130      of STT_FUNC.  */
2131   if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2132     {
2133       h->needs_plt = TRUE;
2134
2135       s = elf_hash_table(info)->splt;
2136       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2137         return FALSE;
2138
2139       /* We need one plt entry per got subsection.  Delay allocation of
2140          the actual plt entries until size_plt_section, called from
2141          size_dynamic_sections or during relaxation.  */
2142
2143       return TRUE;
2144     }
2145   else
2146     h->needs_plt = FALSE;
2147
2148   /* If this is a weak symbol, and there is a real definition, the
2149      processor independent code will have arranged for us to see the
2150      real definition first, and we can just use the same value.  */
2151   if (h->u.weakdef != NULL)
2152     {
2153       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2154                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2155       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2156       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2157       return TRUE;
2158     }
2159
2160   /* This is a reference to a symbol defined by a dynamic object which
2161      is not a function.  The Alpha, since it uses .got entries for all
2162      symbols even in regular objects, does not need the hackery of a
2163      .dynbss section and COPY dynamic relocations.  */
2164
2165   return TRUE;
2166 }
2167
2168 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD.  */
2169
2170 static void
2171 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2172                                     const Elf_Internal_Sym *isym,
2173                                     bfd_boolean definition,
2174                                     bfd_boolean dynamic)
2175 {
2176   if (!dynamic && definition)
2177     h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2178                 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
2179 }
2180
2181 /* Symbol versioning can create new symbols, and make our old symbols
2182    indirect to the new ones.  Consolidate the got and reloc information
2183    in these situations.  */
2184
2185 static void
2186 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2187                                   struct elf_link_hash_entry *dir,
2188                                   struct elf_link_hash_entry *ind)
2189 {
2190   struct alpha_elf_link_hash_entry *hi
2191     = (struct alpha_elf_link_hash_entry *) ind;
2192   struct alpha_elf_link_hash_entry *hs
2193     = (struct alpha_elf_link_hash_entry *) dir;
2194
2195   /* Do the merging in the superclass.  */
2196   _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2197
2198   /* Merge the flags.  Whee.  */
2199   hs->flags |= hi->flags;
2200
2201   /* ??? It's unclear to me what's really supposed to happen when
2202      "merging" defweak and defined symbols, given that we don't
2203      actually throw away the defweak.  This more-or-less copies
2204      the logic related to got and plt entries in the superclass.  */
2205   if (ind->root.type != bfd_link_hash_indirect)
2206     return;
2207
2208   /* Merge the .got entries.  Cannibalize the old symbol's list in
2209      doing so, since we don't need it anymore.  */
2210
2211   if (hs->got_entries == NULL)
2212     hs->got_entries = hi->got_entries;
2213   else
2214     {
2215       struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2216
2217       gsh = hs->got_entries;
2218       for (gi = hi->got_entries; gi ; gi = gin)
2219         {
2220           gin = gi->next;
2221           for (gs = gsh; gs ; gs = gs->next)
2222             if (gi->gotobj == gs->gotobj
2223                 && gi->reloc_type == gs->reloc_type
2224                 && gi->addend == gs->addend)
2225               {
2226                 gs->use_count += gi->use_count;
2227                 goto got_found;
2228               }
2229           gi->next = hs->got_entries;
2230           hs->got_entries = gi;
2231         got_found:;
2232         }
2233     }
2234   hi->got_entries = NULL;
2235
2236   /* And similar for the reloc entries.  */
2237
2238   if (hs->reloc_entries == NULL)
2239     hs->reloc_entries = hi->reloc_entries;
2240   else
2241     {
2242       struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2243
2244       rsh = hs->reloc_entries;
2245       for (ri = hi->reloc_entries; ri ; ri = rin)
2246         {
2247           rin = ri->next;
2248           for (rs = rsh; rs ; rs = rs->next)
2249             if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2250               {
2251                 rs->count += ri->count;
2252                 goto found_reloc;
2253               }
2254           ri->next = hs->reloc_entries;
2255           hs->reloc_entries = ri;
2256         found_reloc:;
2257         }
2258     }
2259   hi->reloc_entries = NULL;
2260 }
2261
2262 /* Is it possible to merge two object file's .got tables?  */
2263
2264 static bfd_boolean
2265 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2266 {
2267   int total = alpha_elf_tdata (a)->total_got_size;
2268   bfd *bsub;
2269
2270   /* Trivial quick fallout test.  */
2271   if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2272     return TRUE;
2273
2274   /* By their nature, local .got entries cannot be merged.  */
2275   if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2276     return FALSE;
2277
2278   /* Failing the common trivial comparison, we must effectively
2279      perform the merge.  Not actually performing the merge means that
2280      we don't have to store undo information in case we fail.  */
2281   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2282     {
2283       struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2284       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2285       int i, n;
2286
2287       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2288       for (i = 0; i < n; ++i)
2289         {
2290           struct alpha_elf_got_entry *ae, *be;
2291           struct alpha_elf_link_hash_entry *h;
2292
2293           h = hashes[i];
2294           while (h->root.root.type == bfd_link_hash_indirect
2295                  || h->root.root.type == bfd_link_hash_warning)
2296             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2297
2298           for (be = h->got_entries; be ; be = be->next)
2299             {
2300               if (be->use_count == 0)
2301                 continue;
2302               if (be->gotobj != b)
2303                 continue;
2304
2305               for (ae = h->got_entries; ae ; ae = ae->next)
2306                 if (ae->gotobj == a
2307                     && ae->reloc_type == be->reloc_type
2308                     && ae->addend == be->addend)
2309                   goto global_found;
2310
2311               total += alpha_got_entry_size (be->reloc_type);
2312               if (total > MAX_GOT_SIZE)
2313                 return FALSE;
2314             global_found:;
2315             }
2316         }
2317     }
2318
2319   return TRUE;
2320 }
2321
2322 /* Actually merge two .got tables.  */
2323
2324 static void
2325 elf64_alpha_merge_gots (bfd *a, bfd *b)
2326 {
2327   int total = alpha_elf_tdata (a)->total_got_size;
2328   bfd *bsub;
2329
2330   /* Remember local expansion.  */
2331   {
2332     int e = alpha_elf_tdata (b)->local_got_size;
2333     total += e;
2334     alpha_elf_tdata (a)->local_got_size += e;
2335   }
2336
2337   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2338     {
2339       struct alpha_elf_got_entry **local_got_entries;
2340       struct alpha_elf_link_hash_entry **hashes;
2341       Elf_Internal_Shdr *symtab_hdr;
2342       int i, n;
2343
2344       /* Let the local .got entries know they are part of a new subsegment.  */
2345       local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2346       if (local_got_entries)
2347         {
2348           n = elf_tdata (bsub)->symtab_hdr.sh_info;
2349           for (i = 0; i < n; ++i)
2350             {
2351               struct alpha_elf_got_entry *ent;
2352               for (ent = local_got_entries[i]; ent; ent = ent->next)
2353                 ent->gotobj = a;
2354             }
2355         }
2356
2357       /* Merge the global .got entries.  */
2358       hashes = alpha_elf_sym_hashes (bsub);
2359       symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2360
2361       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2362       for (i = 0; i < n; ++i)
2363         {
2364           struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2365           struct alpha_elf_link_hash_entry *h;
2366
2367           h = hashes[i];
2368           while (h->root.root.type == bfd_link_hash_indirect
2369                  || h->root.root.type == bfd_link_hash_warning)
2370             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2371
2372           pbe = start = &h->got_entries;
2373           while ((be = *pbe) != NULL)
2374             {
2375               if (be->use_count == 0)
2376                 {
2377                   *pbe = be->next;
2378                   memset (be, 0xa5, sizeof (*be));
2379                   goto kill;
2380                 }
2381               if (be->gotobj != b)
2382                 goto next;
2383
2384               for (ae = *start; ae ; ae = ae->next)
2385                 if (ae->gotobj == a
2386                     && ae->reloc_type == be->reloc_type
2387                     && ae->addend == be->addend)
2388                   {
2389                     ae->flags |= be->flags;
2390                     ae->use_count += be->use_count;
2391                     *pbe = be->next;
2392                     memset (be, 0xa5, sizeof (*be));
2393                     goto kill;
2394                   }
2395               be->gotobj = a;
2396               total += alpha_got_entry_size (be->reloc_type);
2397
2398             next:;
2399               pbe = &be->next;
2400             kill:;
2401             }
2402         }
2403
2404       alpha_elf_tdata (bsub)->gotobj = a;
2405     }
2406   alpha_elf_tdata (a)->total_got_size = total;
2407
2408   /* Merge the two in_got chains.  */
2409   {
2410     bfd *next;
2411
2412     bsub = a;
2413     while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2414       bsub = next;
2415
2416     alpha_elf_tdata (bsub)->in_got_link_next = b;
2417   }
2418 }
2419
2420 /* Calculate the offsets for the got entries.  */
2421
2422 static bfd_boolean
2423 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2424                                          void * arg ATTRIBUTE_UNUSED)
2425 {
2426   struct alpha_elf_got_entry *gotent;
2427
2428   for (gotent = h->got_entries; gotent; gotent = gotent->next)
2429     if (gotent->use_count > 0)
2430       {
2431         struct alpha_elf_obj_tdata *td;
2432         bfd_size_type *plge;
2433
2434         td = alpha_elf_tdata (gotent->gotobj);
2435         plge = &td->got->size;
2436         gotent->got_offset = *plge;
2437         *plge += alpha_got_entry_size (gotent->reloc_type);
2438       }
2439
2440   return TRUE;
2441 }
2442
2443 static void
2444 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2445 {
2446   bfd *i, *got_list;
2447   struct alpha_elf_link_hash_table * htab;
2448
2449   htab = alpha_elf_hash_table (info);
2450   if (htab == NULL)
2451     return;
2452   got_list = htab->got_list;
2453
2454   /* First, zero out the .got sizes, as we may be recalculating the
2455      .got after optimizing it.  */
2456   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2457     alpha_elf_tdata(i)->got->size = 0;
2458
2459   /* Next, fill in the offsets for all the global entries.  */
2460   alpha_elf_link_hash_traverse (htab,
2461                                 elf64_alpha_calc_got_offsets_for_symbol,
2462                                 NULL);
2463
2464   /* Finally, fill in the offsets for the local entries.  */
2465   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2466     {
2467       bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2468       bfd *j;
2469
2470       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2471         {
2472           struct alpha_elf_got_entry **local_got_entries, *gotent;
2473           int k, n;
2474
2475           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2476           if (!local_got_entries)
2477             continue;
2478
2479           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2480             for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2481               if (gotent->use_count > 0)
2482                 {
2483                   gotent->got_offset = got_offset;
2484                   got_offset += alpha_got_entry_size (gotent->reloc_type);
2485                 }
2486         }
2487
2488       alpha_elf_tdata(i)->got->size = got_offset;
2489     }
2490 }
2491
2492 /* Constructs the gots.  */
2493
2494 static bfd_boolean
2495 elf64_alpha_size_got_sections (struct bfd_link_info *info,
2496                                bfd_boolean may_merge)
2497 {
2498   bfd *i, *got_list, *cur_got_obj = NULL;
2499   struct alpha_elf_link_hash_table * htab;
2500
2501   htab = alpha_elf_hash_table (info);
2502   if (htab == NULL)
2503     return FALSE;
2504   got_list = htab->got_list;
2505
2506   /* On the first time through, pretend we have an existing got list
2507      consisting of all of the input files.  */
2508   if (got_list == NULL)
2509     {
2510       for (i = info->input_bfds; i ; i = i->link.next)
2511         {
2512           bfd *this_got;
2513
2514           if (! is_alpha_elf (i))
2515             continue;
2516
2517           this_got = alpha_elf_tdata (i)->gotobj;
2518           if (this_got == NULL)
2519             continue;
2520
2521           /* We are assuming no merging has yet occurred.  */
2522           BFD_ASSERT (this_got == i);
2523
2524           if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2525             {
2526               /* Yikes! A single object file has too many entries.  */
2527               _bfd_error_handler
2528                 /* xgettext:c-format */
2529                 (_("%B: .got subsegment exceeds 64K (size %d)"),
2530                  i, alpha_elf_tdata (this_got)->total_got_size);
2531               return FALSE;
2532             }
2533
2534           if (got_list == NULL)
2535             got_list = this_got;
2536           else
2537             alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2538           cur_got_obj = this_got;
2539         }
2540
2541       /* Strange degenerate case of no got references.  */
2542       if (got_list == NULL)
2543         return TRUE;
2544
2545       htab->got_list = got_list;
2546     }
2547
2548   cur_got_obj = got_list;
2549   if (cur_got_obj == NULL)
2550     return FALSE;
2551
2552   if (may_merge)
2553     {
2554       i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2555       while (i != NULL)
2556         {
2557           if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2558             {
2559               elf64_alpha_merge_gots (cur_got_obj, i);
2560
2561               alpha_elf_tdata(i)->got->size = 0;
2562               i = alpha_elf_tdata(i)->got_link_next;
2563               alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2564             }
2565           else
2566             {
2567               cur_got_obj = i;
2568               i = alpha_elf_tdata(i)->got_link_next;
2569             }
2570         }
2571     }
2572
2573   /* Once the gots have been merged, fill in the got offsets for
2574      everything therein.  */
2575   elf64_alpha_calc_got_offsets (info);
2576
2577   return TRUE;
2578 }
2579
2580 static bfd_boolean
2581 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2582                                 void * data)
2583 {
2584   asection *splt = (asection *) data;
2585   struct alpha_elf_got_entry *gotent;
2586   bfd_boolean saw_one = FALSE;
2587
2588   /* If we didn't need an entry before, we still don't.  */
2589   if (!h->root.needs_plt)
2590     return TRUE;
2591
2592   /* For each LITERAL got entry still in use, allocate a plt entry.  */
2593   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2594     if (gotent->reloc_type == R_ALPHA_LITERAL
2595         && gotent->use_count > 0)
2596       {
2597         if (splt->size == 0)
2598           splt->size = PLT_HEADER_SIZE;
2599         gotent->plt_offset = splt->size;
2600         splt->size += PLT_ENTRY_SIZE;
2601         saw_one = TRUE;
2602       }
2603
2604   /* If there weren't any, there's no longer a need for the PLT entry.  */
2605   if (!saw_one)
2606     h->root.needs_plt = FALSE;
2607
2608   return TRUE;
2609 }
2610
2611 /* Called from relax_section to rebuild the PLT in light of potential changes
2612    in the function's status.  */
2613
2614 static void
2615 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2616 {
2617   asection *splt, *spltrel, *sgotplt;
2618   unsigned long entries;
2619   struct alpha_elf_link_hash_table * htab;
2620
2621   htab = alpha_elf_hash_table (info);
2622   if (htab == NULL)
2623     return;
2624
2625   splt = elf_hash_table(info)->splt;
2626   if (splt == NULL)
2627     return;
2628
2629   splt->size = 0;
2630
2631   alpha_elf_link_hash_traverse (htab,
2632                                 elf64_alpha_size_plt_section_1, splt);
2633
2634   /* Every plt entry requires a JMP_SLOT relocation.  */
2635   spltrel = elf_hash_table(info)->srelplt;
2636   entries = 0;
2637   if (splt->size)
2638     {
2639       if (elf64_alpha_use_secureplt)
2640         entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2641       else
2642         entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2643     }
2644   spltrel->size = entries * sizeof (Elf64_External_Rela);
2645
2646   /* When using the secureplt, we need two words somewhere in the data
2647      segment for the dynamic linker to tell us where to go.  This is the
2648      entire contents of the .got.plt section.  */
2649   if (elf64_alpha_use_secureplt)
2650     {
2651       sgotplt = elf_hash_table(info)->sgotplt;
2652       sgotplt->size = entries ? 16 : 0;
2653     }
2654 }
2655
2656 static bfd_boolean
2657 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2658                                   struct bfd_link_info *info)
2659 {
2660   bfd *i;
2661   struct alpha_elf_link_hash_table * htab;
2662
2663   if (bfd_link_relocatable (info))
2664     return TRUE;
2665
2666   htab = alpha_elf_hash_table (info);
2667   if (htab == NULL)
2668     return FALSE;
2669
2670   if (!elf64_alpha_size_got_sections (info, TRUE))
2671     return FALSE;
2672
2673   /* Allocate space for all of the .got subsections.  */
2674   i = htab->got_list;
2675   for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2676     {
2677       asection *s = alpha_elf_tdata(i)->got;
2678       if (s->size > 0)
2679         {
2680           s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2681           if (s->contents == NULL)
2682             return FALSE;
2683         }
2684     }
2685
2686   return TRUE;
2687 }
2688
2689 /* The number of dynamic relocations required by a static relocation.  */
2690
2691 static int
2692 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2693 {
2694   switch (r_type)
2695     {
2696     /* May appear in GOT entries.  */
2697     case R_ALPHA_TLSGD:
2698       return (dynamic ? 2 : shared ? 1 : 0);
2699     case R_ALPHA_TLSLDM:
2700       return shared;
2701     case R_ALPHA_LITERAL:
2702       return dynamic || shared;
2703     case R_ALPHA_GOTTPREL:
2704       return dynamic || (shared && !pie);
2705     case R_ALPHA_GOTDTPREL:
2706       return dynamic;
2707
2708     /* May appear in data sections.  */
2709     case R_ALPHA_REFLONG:
2710     case R_ALPHA_REFQUAD:
2711       return dynamic || shared;
2712     case R_ALPHA_TPREL64:
2713       return dynamic || (shared && !pie);
2714
2715     /* Everything else is illegal.  We'll issue an error during
2716        relocate_section.  */
2717     default:
2718       return 0;
2719     }
2720 }
2721
2722 /* Work out the sizes of the dynamic relocation entries.  */
2723
2724 static bfd_boolean
2725 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2726                                struct bfd_link_info *info)
2727 {
2728   bfd_boolean dynamic;
2729   struct alpha_elf_reloc_entry *relent;
2730   unsigned long entries;
2731
2732   /* If the symbol was defined as a common symbol in a regular object
2733      file, and there was no definition in any dynamic object, then the
2734      linker will have allocated space for the symbol in a common
2735      section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2736      set.  This is done for dynamic symbols in
2737      elf_adjust_dynamic_symbol but this is not done for non-dynamic
2738      symbols, somehow.  */
2739   if (!h->root.def_regular
2740       && h->root.ref_regular
2741       && !h->root.def_dynamic
2742       && (h->root.root.type == bfd_link_hash_defined
2743           || h->root.root.type == bfd_link_hash_defweak)
2744       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2745     h->root.def_regular = 1;
2746
2747   /* If the symbol is dynamic, we'll need all the relocations in their
2748      natural form.  If this is a shared object, and it has been forced
2749      local, we'll need the same number of RELATIVE relocations.  */
2750   dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2751
2752   /* If the symbol is a hidden undefined weak, then we never have any
2753      relocations.  Avoid the loop which may want to add RELATIVE relocs
2754      based on bfd_link_pic (info).  */
2755   if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2756     return TRUE;
2757
2758   for (relent = h->reloc_entries; relent; relent = relent->next)
2759     {
2760       entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2761                                                  bfd_link_pic (info),
2762                                                  bfd_link_pie (info));
2763       if (entries)
2764         {
2765           relent->srel->size +=
2766             entries * sizeof (Elf64_External_Rela) * relent->count;
2767           if (relent->reltext)
2768             info->flags |= DT_TEXTREL;
2769         }
2770     }
2771
2772   return TRUE;
2773 }
2774
2775 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2776    global symbols.  */
2777
2778 static bfd_boolean
2779 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2780                              struct bfd_link_info *info)
2781 {
2782   bfd_boolean dynamic;
2783   struct alpha_elf_got_entry *gotent;
2784   unsigned long entries;
2785
2786   /* If we're using a plt for this symbol, then all of its relocations
2787      for its got entries go into .rela.plt.  */
2788   if (h->root.needs_plt)
2789     return TRUE;
2790
2791   /* If the symbol is dynamic, we'll need all the relocations in their
2792      natural form.  If this is a shared object, and it has been forced
2793      local, we'll need the same number of RELATIVE relocations.  */
2794   dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2795
2796   /* If the symbol is a hidden undefined weak, then we never have any
2797      relocations.  Avoid the loop which may want to add RELATIVE relocs
2798      based on bfd_link_pic (info).  */
2799   if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2800     return TRUE;
2801
2802   entries = 0;
2803   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2804     if (gotent->use_count > 0)
2805       entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2806                                                   bfd_link_pic (info),
2807                                                   bfd_link_pie (info));
2808
2809   if (entries > 0)
2810     {
2811       asection *srel = elf_hash_table(info)->srelgot;
2812       BFD_ASSERT (srel != NULL);
2813       srel->size += sizeof (Elf64_External_Rela) * entries;
2814     }
2815
2816   return TRUE;
2817 }
2818
2819 /* Set the sizes of the dynamic relocation sections.  */
2820
2821 static void
2822 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2823 {
2824   unsigned long entries;
2825   bfd *i;
2826   asection *srel;
2827   struct alpha_elf_link_hash_table * htab;
2828
2829   htab = alpha_elf_hash_table (info);
2830   if (htab == NULL)
2831     return;
2832
2833   /* Shared libraries often require RELATIVE relocs, and some relocs
2834      require attention for the main application as well.  */
2835
2836   entries = 0;
2837   for (i = htab->got_list;
2838        i ; i = alpha_elf_tdata(i)->got_link_next)
2839     {
2840       bfd *j;
2841
2842       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2843         {
2844           struct alpha_elf_got_entry **local_got_entries, *gotent;
2845           int k, n;
2846
2847           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2848           if (!local_got_entries)
2849             continue;
2850
2851           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2852             for (gotent = local_got_entries[k];
2853                  gotent ; gotent = gotent->next)
2854               if (gotent->use_count > 0)
2855                 entries += (alpha_dynamic_entries_for_reloc
2856                             (gotent->reloc_type, 0, bfd_link_pic (info),
2857                              bfd_link_pie (info)));
2858         }
2859     }
2860
2861   srel = elf_hash_table(info)->srelgot;
2862   if (!srel)
2863     {
2864       BFD_ASSERT (entries == 0);
2865       return;
2866     }
2867   srel->size = sizeof (Elf64_External_Rela) * entries;
2868
2869   /* Now do the non-local symbols.  */
2870   alpha_elf_link_hash_traverse (htab,
2871                                 elf64_alpha_size_rela_got_1, info);
2872 }
2873
2874 /* Set the sizes of the dynamic sections.  */
2875
2876 static bfd_boolean
2877 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2878                                    struct bfd_link_info *info)
2879 {
2880   bfd *dynobj;
2881   asection *s;
2882   bfd_boolean relplt;
2883   struct alpha_elf_link_hash_table * htab;
2884
2885   htab = alpha_elf_hash_table (info);
2886   if (htab == NULL)
2887     return FALSE;
2888
2889   dynobj = elf_hash_table(info)->dynobj;
2890   BFD_ASSERT(dynobj != NULL);
2891
2892   if (elf_hash_table (info)->dynamic_sections_created)
2893     {
2894       /* Set the contents of the .interp section to the interpreter.  */
2895       if (bfd_link_executable (info) && !info->nointerp)
2896         {
2897           s = bfd_get_linker_section (dynobj, ".interp");
2898           BFD_ASSERT (s != NULL);
2899           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2900           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2901         }
2902
2903       /* Now that we've seen all of the input files, we can decide which
2904          symbols need dynamic relocation entries and which don't.  We've
2905          collected information in check_relocs that we can now apply to
2906          size the dynamic relocation sections.  */
2907       alpha_elf_link_hash_traverse (htab,
2908                                     elf64_alpha_calc_dynrel_sizes, info);
2909
2910       elf64_alpha_size_rela_got_section (info);
2911       elf64_alpha_size_plt_section (info);
2912     }
2913   /* else we're not dynamic and by definition we don't need such things.  */
2914
2915   /* The check_relocs and adjust_dynamic_symbol entry points have
2916      determined the sizes of the various dynamic sections.  Allocate
2917      memory for them.  */
2918   relplt = FALSE;
2919   for (s = dynobj->sections; s != NULL; s = s->next)
2920     {
2921       const char *name;
2922
2923       if (!(s->flags & SEC_LINKER_CREATED))
2924         continue;
2925
2926       /* It's OK to base decisions on the section name, because none
2927          of the dynobj section names depend upon the input files.  */
2928       name = bfd_get_section_name (dynobj, s);
2929
2930       if (CONST_STRNEQ (name, ".rela"))
2931         {
2932           if (s->size != 0)
2933             {
2934               if (strcmp (name, ".rela.plt") == 0)
2935                 relplt = TRUE;
2936
2937               /* We use the reloc_count field as a counter if we need
2938                  to copy relocs into the output file.  */
2939               s->reloc_count = 0;
2940             }
2941         }
2942       else if (! CONST_STRNEQ (name, ".got")
2943                && strcmp (name, ".plt") != 0
2944                && strcmp (name, ".dynbss") != 0)
2945         {
2946           /* It's not one of our dynamic sections, so don't allocate space.  */
2947           continue;
2948         }
2949
2950       if (s->size == 0)
2951         {
2952           /* If we don't need this section, strip it from the output file.
2953              This is to handle .rela.bss and .rela.plt.  We must create it
2954              in create_dynamic_sections, because it must be created before
2955              the linker maps input sections to output sections.  The
2956              linker does that before adjust_dynamic_symbol is called, and
2957              it is that function which decides whether anything needs to
2958              go into these sections.  */
2959           if (!CONST_STRNEQ (name, ".got"))
2960             s->flags |= SEC_EXCLUDE;
2961         }
2962       else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2963         {
2964           /* Allocate memory for the section contents.  */
2965           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2966           if (s->contents == NULL)
2967             return FALSE;
2968         }
2969     }
2970
2971   if (elf_hash_table (info)->dynamic_sections_created)
2972     {
2973       /* Add some entries to the .dynamic section.  We fill in the
2974          values later, in elf64_alpha_finish_dynamic_sections, but we
2975          must add the entries now so that we get the correct size for
2976          the .dynamic section.  The DT_DEBUG entry is filled in by the
2977          dynamic linker and used by the debugger.  */
2978 #define add_dynamic_entry(TAG, VAL) \
2979   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2980
2981       if (bfd_link_executable (info))
2982         {
2983           if (!add_dynamic_entry (DT_DEBUG, 0))
2984             return FALSE;
2985         }
2986
2987       if (relplt)
2988         {
2989           if (!add_dynamic_entry (DT_PLTGOT, 0)
2990               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2991               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2992               || !add_dynamic_entry (DT_JMPREL, 0))
2993             return FALSE;
2994
2995           if (elf64_alpha_use_secureplt
2996               && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2997             return FALSE;
2998         }
2999
3000       if (!add_dynamic_entry (DT_RELA, 0)
3001           || !add_dynamic_entry (DT_RELASZ, 0)
3002           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3003         return FALSE;
3004
3005       if (info->flags & DF_TEXTREL)
3006         {
3007           if (!add_dynamic_entry (DT_TEXTREL, 0))
3008             return FALSE;
3009         }
3010     }
3011 #undef add_dynamic_entry
3012
3013   return TRUE;
3014 }
3015 \f
3016 /* These functions do relaxation for Alpha ELF.
3017
3018    Currently I'm only handling what I can do with existing compiler
3019    and assembler support, which means no instructions are removed,
3020    though some may be nopped.  At this time GCC does not emit enough
3021    information to do all of the relaxing that is possible.  It will
3022    take some not small amount of work for that to happen.
3023
3024    There are a couple of interesting papers that I once read on this
3025    subject, that I cannot find references to at the moment, that
3026    related to Alpha in particular.  They are by David Wall, then of
3027    DEC WRL.  */
3028
3029 struct alpha_relax_info
3030 {
3031   bfd *abfd;
3032   asection *sec;
3033   bfd_byte *contents;
3034   Elf_Internal_Shdr *symtab_hdr;
3035   Elf_Internal_Rela *relocs, *relend;
3036   struct bfd_link_info *link_info;
3037   bfd_vma gp;
3038   bfd *gotobj;
3039   asection *tsec;
3040   struct alpha_elf_link_hash_entry *h;
3041   struct alpha_elf_got_entry **first_gotent;
3042   struct alpha_elf_got_entry *gotent;
3043   bfd_boolean changed_contents;
3044   bfd_boolean changed_relocs;
3045   unsigned char other;
3046 };
3047
3048 static Elf_Internal_Rela *
3049 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
3050                                Elf_Internal_Rela *relend,
3051                                bfd_vma offset, int type)
3052 {
3053   while (rel < relend)
3054     {
3055       if (rel->r_offset == offset
3056           && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
3057         return rel;
3058       ++rel;
3059     }
3060   return NULL;
3061 }
3062
3063 static bfd_boolean
3064 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3065                             Elf_Internal_Rela *irel, unsigned long r_type)
3066 {
3067   unsigned int insn;
3068   bfd_signed_vma disp;
3069
3070   /* Get the instruction.  */
3071   insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3072
3073   if (insn >> 26 != OP_LDQ)
3074     {
3075       reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3076       _bfd_error_handler
3077         /* xgettext:c-format */
3078         (_("%B: %A+0x%lx: warning: %s relocation against unexpected insn"),
3079          info->abfd, info->sec,
3080          (unsigned long) irel->r_offset, howto->name);
3081       return TRUE;
3082     }
3083
3084   /* Can't relax dynamic symbols.  */
3085   if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3086     return TRUE;
3087
3088   /* Can't use local-exec relocations in shared libraries.  */
3089   if (r_type == R_ALPHA_GOTTPREL
3090       && bfd_link_dll (info->link_info))
3091     return TRUE;
3092
3093   if (r_type == R_ALPHA_LITERAL)
3094     {
3095       /* Look for nice constant addresses.  This includes the not-uncommon
3096          special case of 0 for undefweak symbols.  */
3097       if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3098           || (!bfd_link_pic (info->link_info)
3099               && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3100         {
3101           disp = 0;
3102           insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3103           insn |= (symval & 0xffff);
3104           r_type = R_ALPHA_NONE;
3105         }
3106       else
3107         {
3108           /* We may only create GPREL relocs during the second pass.  */
3109           if (info->link_info->relax_pass == 0)
3110             return TRUE;
3111
3112           disp = symval - info->gp;
3113           insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3114           r_type = R_ALPHA_GPREL16;
3115         }
3116     }
3117   else
3118     {
3119       bfd_vma dtp_base, tp_base;
3120
3121       BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3122       dtp_base = alpha_get_dtprel_base (info->link_info);
3123       tp_base = alpha_get_tprel_base (info->link_info);
3124       disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3125
3126       insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3127
3128       switch (r_type)
3129         {
3130         case R_ALPHA_GOTDTPREL:
3131           r_type = R_ALPHA_DTPREL16;
3132           break;
3133         case R_ALPHA_GOTTPREL:
3134           r_type = R_ALPHA_TPREL16;
3135           break;
3136         default:
3137           BFD_ASSERT (0);
3138           return FALSE;
3139         }
3140     }
3141
3142   if (disp < -0x8000 || disp >= 0x8000)
3143     return TRUE;
3144
3145   bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3146   info->changed_contents = TRUE;
3147
3148   /* Reduce the use count on this got entry by one, possibly
3149      eliminating it.  */
3150   if (--info->gotent->use_count == 0)
3151     {
3152       int sz = alpha_got_entry_size (r_type);
3153       alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3154       if (!info->h)
3155         alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3156     }
3157
3158   /* Smash the existing GOT relocation for its 16-bit immediate pair.  */
3159   irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3160   info->changed_relocs = TRUE;
3161
3162   /* ??? Search forward through this basic block looking for insns
3163      that use the target register.  Stop after an insn modifying the
3164      register is seen, or after a branch or call.
3165
3166      Any such memory load insn may be substituted by a load directly
3167      off the GP.  This allows the memory load insn to be issued before
3168      the calculated GP register would otherwise be ready.
3169
3170      Any such jsr insn can be replaced by a bsr if it is in range.
3171
3172      This would mean that we'd have to _add_ relocations, the pain of
3173      which gives one pause.  */
3174
3175   return TRUE;
3176 }
3177
3178 static bfd_vma
3179 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3180 {
3181   /* If the function has the same gp, and we can identify that the
3182      function does not use its function pointer, we can eliminate the
3183      address load.  */
3184
3185   /* If the symbol is marked NOPV, we are being told the function never
3186      needs its procedure value.  */
3187   if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3188     return symval;
3189
3190   /* If the symbol is marked STD_GP, we are being told the function does
3191      a normal ldgp in the first two words.  */
3192   else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3193     ;
3194
3195   /* Otherwise, we may be able to identify a GP load in the first two
3196      words, which we can then skip.  */
3197   else
3198     {
3199       Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3200       bfd_vma ofs;
3201
3202       /* Load the relocations from the section that the target symbol is in.  */
3203       if (info->sec == info->tsec)
3204         {
3205           tsec_relocs = info->relocs;
3206           tsec_relend = info->relend;
3207           tsec_free = NULL;
3208         }
3209       else
3210         {
3211           tsec_relocs = (_bfd_elf_link_read_relocs
3212                          (info->abfd, info->tsec, NULL,
3213                          (Elf_Internal_Rela *) NULL,
3214                          info->link_info->keep_memory));
3215           if (tsec_relocs == NULL)
3216             return 0;
3217           tsec_relend = tsec_relocs + info->tsec->reloc_count;
3218           tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
3219         }
3220
3221       /* Recover the symbol's offset within the section.  */
3222       ofs = (symval - info->tsec->output_section->vma
3223              - info->tsec->output_offset);
3224
3225       /* Look for a GPDISP reloc.  */
3226       gpdisp = (elf64_alpha_find_reloc_at_ofs
3227                 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3228
3229       if (!gpdisp || gpdisp->r_addend != 4)
3230         {
3231           if (tsec_free)
3232             free (tsec_free);
3233           return 0;
3234         }
3235       if (tsec_free)
3236         free (tsec_free);
3237     }
3238
3239   /* We've now determined that we can skip an initial gp load.  Verify
3240      that the call and the target use the same gp.   */
3241   if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3242       || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3243     return 0;
3244
3245   return symval + 8;
3246 }
3247
3248 static bfd_boolean
3249 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3250                                bfd_vma symval, Elf_Internal_Rela *irel)
3251 {
3252   Elf_Internal_Rela *urel, *erel, *irelend = info->relend;
3253   int flags;
3254   bfd_signed_vma disp;
3255   bfd_boolean fits16;
3256   bfd_boolean fits32;
3257   bfd_boolean lit_reused = FALSE;
3258   bfd_boolean all_optimized = TRUE;
3259   bfd_boolean changed_contents;
3260   bfd_boolean changed_relocs;
3261   bfd_byte *contents = info->contents;
3262   bfd *abfd = info->abfd;
3263   bfd_vma sec_output_vma;
3264   unsigned int lit_insn;
3265   int relax_pass;
3266
3267   lit_insn = bfd_get_32 (abfd, contents + irel->r_offset);
3268   if (lit_insn >> 26 != OP_LDQ)
3269     {
3270       _bfd_error_handler
3271         /* xgettext:c-format */
3272         (_("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn"),
3273          abfd, info->sec,
3274          (unsigned long) irel->r_offset);
3275       return TRUE;
3276     }
3277
3278   /* Can't relax dynamic symbols.  */
3279   if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3280     return TRUE;
3281
3282   changed_contents = info->changed_contents;
3283   changed_relocs = info->changed_relocs;
3284   sec_output_vma = info->sec->output_section->vma + info->sec->output_offset;
3285   relax_pass = info->link_info->relax_pass;
3286
3287   /* Summarize how this particular LITERAL is used.  */
3288   for (erel = irel+1, flags = 0; erel < irelend; ++erel)
3289     {
3290       if (ELF64_R_TYPE (erel->r_info) != R_ALPHA_LITUSE)
3291         break;
3292       if (erel->r_addend <= 6)
3293         flags |= 1 << erel->r_addend;
3294     }
3295
3296   /* A little preparation for the loop...  */
3297   disp = symval - info->gp;
3298
3299   for (urel = irel+1; urel < erel; ++urel)
3300     {
3301       bfd_vma urel_r_offset = urel->r_offset;
3302       unsigned int insn;
3303       int insn_disp;
3304       bfd_signed_vma xdisp;
3305       Elf_Internal_Rela nrel;
3306
3307       insn = bfd_get_32 (abfd, contents + urel_r_offset);
3308
3309       switch (urel->r_addend)
3310         {
3311         case LITUSE_ALPHA_ADDR:
3312         default:
3313           /* This type is really just a placeholder to note that all
3314              uses cannot be optimized, but to still allow some.  */
3315           all_optimized = FALSE;
3316           break;
3317
3318         case LITUSE_ALPHA_BASE:
3319           /* We may only create GPREL relocs during the second pass.  */
3320           if (relax_pass == 0)
3321             {
3322               all_optimized = FALSE;
3323               break;
3324             }
3325
3326           /* We can always optimize 16-bit displacements.  */
3327
3328           /* Extract the displacement from the instruction, sign-extending
3329              it if necessary, then test whether it is within 16 or 32 bits
3330              displacement from GP.  */
3331           insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3332
3333           xdisp = disp + insn_disp;
3334           fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3335           fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3336                     && xdisp < 0x7fff8000);
3337
3338           if (fits16)
3339             {
3340               /* Take the op code and dest from this insn, take the base
3341                  register from the literal insn.  Leave the offset alone.  */
3342               insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3343               bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3344               changed_contents = TRUE;
3345
3346               nrel = *urel;
3347               nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3348                                           R_ALPHA_GPREL16);
3349               nrel.r_addend = irel->r_addend;
3350
3351               /* As we adjust, move the reloc to the end so that we don't
3352                  break the LITERAL+LITUSE chain.  */
3353               if (urel < --erel)
3354                 *urel-- = *erel;
3355               *erel = nrel;
3356               changed_relocs = TRUE;
3357             }
3358
3359           /* If all mem+byte, we can optimize 32-bit mem displacements.  */
3360           else if (fits32 && !(flags & ~6))
3361             {
3362               /* FIXME: sanity check that lit insn Ra is mem insn Rb.  */
3363
3364               irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3365                                            R_ALPHA_GPRELHIGH);
3366               lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3367               bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset);
3368               lit_reused = TRUE;
3369               changed_contents = TRUE;
3370
3371               /* Since all relocs must be optimized, don't bother swapping
3372                  this relocation to the end.  */
3373               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3374                                            R_ALPHA_GPRELLOW);
3375               urel->r_addend = irel->r_addend;
3376               changed_relocs = TRUE;
3377             }
3378           else
3379             all_optimized = FALSE;
3380           break;
3381
3382         case LITUSE_ALPHA_BYTOFF:
3383           /* We can always optimize byte instructions.  */
3384
3385           /* FIXME: sanity check the insn for byte op.  Check that the
3386              literal dest reg is indeed Rb in the byte insn.  */
3387
3388           insn &= ~ (unsigned) 0x001ff000;
3389           insn |= ((symval & 7) << 13) | 0x1000;
3390           bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3391           changed_contents = TRUE;
3392
3393           nrel = *urel;
3394           nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3395           nrel.r_addend = 0;
3396
3397           /* As we adjust, move the reloc to the end so that we don't
3398              break the LITERAL+LITUSE chain.  */
3399           if (urel < --erel)
3400             *urel-- = *erel;
3401           *erel = nrel;
3402           changed_relocs = TRUE;
3403           break;
3404
3405         case LITUSE_ALPHA_JSR:
3406         case LITUSE_ALPHA_TLSGD:
3407         case LITUSE_ALPHA_TLSLDM:
3408         case LITUSE_ALPHA_JSRDIRECT:
3409           {
3410             bfd_vma optdest, org;
3411             bfd_signed_vma odisp;
3412
3413             /* For undefined weak symbols, we're mostly interested in getting
3414                rid of the got entry whenever possible, so optimize this to a
3415                use of the zero register.  */
3416             if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3417               {
3418                 insn |= 31 << 16;
3419                 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3420
3421                 changed_contents = TRUE;
3422                 break;
3423               }
3424
3425             /* If not zero, place to jump without needing pv.  */
3426             optdest = elf64_alpha_relax_opt_call (info, symval);
3427             org = sec_output_vma + urel_r_offset + 4;
3428             odisp = (optdest ? optdest : symval) - org;
3429
3430             if (odisp >= -0x400000 && odisp < 0x400000)
3431               {
3432                 Elf_Internal_Rela *xrel;
3433
3434                 /* Preserve branch prediction call stack when possible.  */
3435                 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3436                   insn = (OP_BSR << 26) | (insn & 0x03e00000);
3437                 else
3438                   insn = (OP_BR << 26) | (insn & 0x03e00000);
3439                 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3440                 changed_contents = TRUE;
3441
3442                 nrel = *urel;
3443                 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3444                                             R_ALPHA_BRADDR);
3445                 nrel.r_addend = irel->r_addend;
3446
3447                 if (optdest)
3448                   nrel.r_addend += optdest - symval;
3449                 else
3450                   all_optimized = FALSE;
3451
3452                 /* Kill any HINT reloc that might exist for this insn.  */
3453                 xrel = (elf64_alpha_find_reloc_at_ofs
3454                         (info->relocs, info->relend, urel_r_offset,
3455                          R_ALPHA_HINT));
3456                 if (xrel)
3457                   xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3458
3459                 /* As we adjust, move the reloc to the end so that we don't
3460                    break the LITERAL+LITUSE chain.  */
3461                 if (urel < --erel)
3462                   *urel-- = *erel;
3463                 *erel = nrel;
3464
3465                 info->changed_relocs = TRUE;
3466               }
3467             else
3468               all_optimized = FALSE;
3469
3470             /* Even if the target is not in range for a direct branch,
3471                if we share a GP, we can eliminate the gp reload.  */
3472             if (optdest)
3473               {
3474                 Elf_Internal_Rela *gpdisp
3475                   = (elf64_alpha_find_reloc_at_ofs
3476                      (info->relocs, irelend, urel_r_offset + 4,
3477                       R_ALPHA_GPDISP));
3478                 if (gpdisp)
3479                   {
3480                     bfd_byte *p_ldah = contents + gpdisp->r_offset;
3481                     bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3482                     unsigned int ldah = bfd_get_32 (abfd, p_ldah);
3483                     unsigned int lda = bfd_get_32 (abfd, p_lda);
3484
3485                     /* Verify that the instruction is "ldah $29,0($26)".
3486                        Consider a function that ends in a noreturn call,
3487                        and that the next function begins with an ldgp,
3488                        and that by accident there is no padding between.
3489                        In that case the insn would use $27 as the base.  */
3490                     if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3491                       {
3492                         bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_ldah);
3493                         bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda);
3494
3495                         gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3496                         changed_contents = TRUE;
3497                         changed_relocs = TRUE;
3498                       }
3499                   }
3500               }
3501           }
3502           break;
3503         }
3504     }
3505
3506   /* If we reused the literal instruction, we must have optimized all.  */
3507   BFD_ASSERT(!lit_reused || all_optimized);
3508
3509   /* If all cases were optimized, we can reduce the use count on this
3510      got entry by one, possibly eliminating it.  */
3511   if (all_optimized)
3512     {
3513       if (--info->gotent->use_count == 0)
3514         {
3515           int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3516           alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3517           if (!info->h)
3518             alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3519         }
3520
3521       /* If the literal instruction is no longer needed (it may have been
3522          reused.  We can eliminate it.  */
3523       /* ??? For now, I don't want to deal with compacting the section,
3524          so just nop it out.  */
3525       if (!lit_reused)
3526         {
3527           irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3528           changed_relocs = TRUE;
3529
3530           bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset);
3531           changed_contents = TRUE;
3532         }
3533     }
3534
3535   info->changed_contents = changed_contents;
3536   info->changed_relocs = changed_relocs;
3537
3538   if (all_optimized || relax_pass == 0)
3539     return TRUE;
3540   return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3541 }
3542
3543 static bfd_boolean
3544 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3545                                 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3546 {
3547   bfd_byte *pos[5];
3548   unsigned int insn, tlsgd_reg;
3549   Elf_Internal_Rela *gpdisp, *hint;
3550   bfd_boolean dynamic, use_gottprel;
3551   unsigned long new_symndx;
3552
3553   dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3554
3555   /* If a TLS symbol is accessed using IE at least once, there is no point
3556      to use dynamic model for it.  */
3557   if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3558     ;
3559
3560   /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3561      then we might as well relax to IE.  */
3562   else if (bfd_link_pic (info->link_info) && !dynamic
3563            && (info->link_info->flags & DF_STATIC_TLS))
3564     ;
3565
3566   /* Otherwise we must be building an executable to do anything.  */
3567   else if (bfd_link_pic (info->link_info))
3568     return TRUE;
3569
3570   /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3571      the matching LITUSE_TLS relocations.  */
3572   if (irel + 2 >= info->relend)
3573     return TRUE;
3574   if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3575       || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3576       || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3577     return TRUE;
3578
3579   /* There must be a GPDISP relocation positioned immediately after the
3580      LITUSE relocation.  */
3581   gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3582                                           irel[2].r_offset + 4, R_ALPHA_GPDISP);
3583   if (!gpdisp)
3584     return TRUE;
3585
3586   pos[0] = info->contents + irel[0].r_offset;
3587   pos[1] = info->contents + irel[1].r_offset;
3588   pos[2] = info->contents + irel[2].r_offset;
3589   pos[3] = info->contents + gpdisp->r_offset;
3590   pos[4] = pos[3] + gpdisp->r_addend;
3591
3592   /* Beware of the compiler hoisting part of the sequence out a loop
3593      and adjusting the destination register for the TLSGD insn.  If this
3594      happens, there will be a move into $16 before the JSR insn, so only
3595      transformations of the first insn pair should use this register.  */
3596   tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3597   tlsgd_reg = (tlsgd_reg >> 21) & 31;
3598
3599   /* Generally, the positions are not allowed to be out of order, lest the
3600      modified insn sequence have different register lifetimes.  We can make
3601      an exception when pos 1 is adjacent to pos 0.  */
3602   if (pos[1] + 4 == pos[0])
3603     {
3604       bfd_byte *tmp = pos[0];
3605       pos[0] = pos[1];
3606       pos[1] = tmp;
3607     }
3608   if (pos[1] >= pos[2] || pos[2] >= pos[3])
3609     return TRUE;
3610
3611   /* Reduce the use count on the LITERAL relocation.  Do this before we
3612      smash the symndx when we adjust the relocations below.  */
3613   {
3614     struct alpha_elf_got_entry *lit_gotent;
3615     struct alpha_elf_link_hash_entry *lit_h;
3616     unsigned long indx;
3617
3618     BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3619     indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3620     lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3621
3622     while (lit_h->root.root.type == bfd_link_hash_indirect
3623            || lit_h->root.root.type == bfd_link_hash_warning)
3624       lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3625
3626     for (lit_gotent = lit_h->got_entries; lit_gotent ;
3627          lit_gotent = lit_gotent->next)
3628       if (lit_gotent->gotobj == info->gotobj
3629           && lit_gotent->reloc_type == R_ALPHA_LITERAL
3630           && lit_gotent->addend == irel[1].r_addend)
3631         break;
3632     BFD_ASSERT (lit_gotent);
3633
3634     if (--lit_gotent->use_count == 0)
3635       {
3636         int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3637         alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3638       }
3639   }
3640
3641   /* Change
3642
3643         lda     $16,x($gp)                      !tlsgd!1
3644         ldq     $27,__tls_get_addr($gp)         !literal!1
3645         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
3646         ldah    $29,0($26)                      !gpdisp!2
3647         lda     $29,0($29)                      !gpdisp!2
3648      to
3649         ldq     $16,x($gp)                      !gottprel
3650         unop
3651         call_pal rduniq
3652         addq    $16,$0,$0
3653         unop
3654      or the first pair to
3655         lda     $16,x($gp)                      !tprel
3656         unop
3657      or
3658         ldah    $16,x($gp)                      !tprelhi
3659         lda     $16,x($16)                      !tprello
3660
3661      as appropriate.  */
3662
3663   use_gottprel = FALSE;
3664   new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3665
3666   /* Some compilers warn about a Boolean-looking expression being
3667      used in a switch.  The explicit cast silences them.  */
3668   switch ((int) (!dynamic && !bfd_link_pic (info->link_info)))
3669     {
3670     case 1:
3671       {
3672         bfd_vma tp_base;
3673         bfd_signed_vma disp;
3674
3675         BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3676         tp_base = alpha_get_tprel_base (info->link_info);
3677         disp = symval - tp_base;
3678
3679         if (disp >= -0x8000 && disp < 0x8000)
3680           {
3681             insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3682             bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3683             bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3684
3685             irel[0].r_offset = pos[0] - info->contents;
3686             irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3687             irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3688             break;
3689           }
3690         else if (disp >= -(bfd_signed_vma) 0x80000000
3691                  && disp < (bfd_signed_vma) 0x7fff8000
3692                  && pos[0] + 4 == pos[1])
3693           {
3694             insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3695             bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3696             insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3697             bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3698
3699             irel[0].r_offset = pos[0] - info->contents;
3700             irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3701             irel[1].r_offset = pos[1] - info->contents;
3702             irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3703             break;
3704           }
3705       }
3706       /* FALLTHRU */
3707
3708     default:
3709       use_gottprel = TRUE;
3710
3711       insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3712       bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3713       bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3714
3715       irel[0].r_offset = pos[0] - info->contents;
3716       irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3717       irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3718       break;
3719     }
3720
3721   bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3722
3723   insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3724   bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3725
3726   bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3727
3728   irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3729   gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3730
3731   hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3732                                         irel[2].r_offset, R_ALPHA_HINT);
3733   if (hint)
3734     hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3735
3736   info->changed_contents = TRUE;
3737   info->changed_relocs = TRUE;
3738
3739   /* Reduce the use count on the TLSGD/TLSLDM relocation.  */
3740   if (--info->gotent->use_count == 0)
3741     {
3742       int sz = alpha_got_entry_size (info->gotent->reloc_type);
3743       alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3744       if (!info->h)
3745         alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3746     }
3747
3748   /* If we've switched to a GOTTPREL relocation, increment the reference
3749      count on that got entry.  */
3750   if (use_gottprel)
3751     {
3752       struct alpha_elf_got_entry *tprel_gotent;
3753
3754       for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3755            tprel_gotent = tprel_gotent->next)
3756         if (tprel_gotent->gotobj == info->gotobj
3757             && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3758             && tprel_gotent->addend == irel->r_addend)
3759           break;
3760       if (tprel_gotent)
3761         tprel_gotent->use_count++;
3762       else
3763         {
3764           if (info->gotent->use_count == 0)
3765             tprel_gotent = info->gotent;
3766           else
3767             {
3768               tprel_gotent = (struct alpha_elf_got_entry *)
3769                 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3770               if (!tprel_gotent)
3771                 return FALSE;
3772
3773               tprel_gotent->next = *info->first_gotent;
3774               *info->first_gotent = tprel_gotent;
3775
3776               tprel_gotent->gotobj = info->gotobj;
3777               tprel_gotent->addend = irel->r_addend;
3778               tprel_gotent->got_offset = -1;
3779               tprel_gotent->reloc_done = 0;
3780               tprel_gotent->reloc_xlated = 0;
3781             }
3782
3783           tprel_gotent->use_count = 1;
3784           tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3785         }
3786     }
3787
3788   return TRUE;
3789 }
3790
3791 static bfd_boolean
3792 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3793                            struct bfd_link_info *link_info, bfd_boolean *again)
3794 {
3795   Elf_Internal_Shdr *symtab_hdr;
3796   Elf_Internal_Rela *internal_relocs;
3797   Elf_Internal_Rela *irel, *irelend;
3798   Elf_Internal_Sym *isymbuf = NULL;
3799   struct alpha_elf_got_entry **local_got_entries;
3800   struct alpha_relax_info info;
3801   struct alpha_elf_link_hash_table * htab;
3802   int relax_pass;
3803
3804   htab = alpha_elf_hash_table (link_info);
3805   if (htab == NULL)
3806     return FALSE;
3807
3808   /* There's nothing to change, yet.  */
3809   *again = FALSE;
3810
3811   if (bfd_link_relocatable (link_info)
3812       || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3813           != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3814       || sec->reloc_count == 0)
3815     return TRUE;
3816
3817   BFD_ASSERT (is_alpha_elf (abfd));
3818   relax_pass = link_info->relax_pass;
3819
3820   /* Make sure our GOT and PLT tables are up-to-date.  */
3821   if (htab->relax_trip != link_info->relax_trip)
3822     {
3823       htab->relax_trip = link_info->relax_trip;
3824
3825       /* This should never fail after the initial round, since the only error
3826          is GOT overflow, and relaxation only shrinks the table.  However, we
3827          may only merge got sections during the first pass.  If we merge
3828          sections after we've created GPREL relocs, the GP for the merged
3829          section backs up which may put the relocs out of range.  */
3830       if (!elf64_alpha_size_got_sections (link_info, relax_pass == 0))
3831         abort ();
3832       if (elf_hash_table (link_info)->dynamic_sections_created)
3833         {
3834           elf64_alpha_size_plt_section (link_info);
3835           elf64_alpha_size_rela_got_section (link_info);
3836         }
3837     }
3838
3839   symtab_hdr = &elf_symtab_hdr (abfd);
3840   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3841
3842   /* Load the relocations for this section.  */
3843   internal_relocs = (_bfd_elf_link_read_relocs
3844                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3845                       link_info->keep_memory));
3846   if (internal_relocs == NULL)
3847     return FALSE;
3848
3849   memset(&info, 0, sizeof (info));
3850   info.abfd = abfd;
3851   info.sec = sec;
3852   info.link_info = link_info;
3853   info.symtab_hdr = symtab_hdr;
3854   info.relocs = internal_relocs;
3855   info.relend = irelend = internal_relocs + sec->reloc_count;
3856
3857   /* Find the GP for this object.  Do not store the result back via
3858      _bfd_set_gp_value, since this could change again before final.  */
3859   info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3860   if (info.gotobj)
3861     {
3862       asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3863       info.gp = (sgot->output_section->vma
3864                  + sgot->output_offset
3865                  + 0x8000);
3866     }
3867
3868   /* Get the section contents.  */
3869   if (elf_section_data (sec)->this_hdr.contents != NULL)
3870     info.contents = elf_section_data (sec)->this_hdr.contents;
3871   else
3872     {
3873       if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3874         goto error_return;
3875     }
3876
3877   for (irel = internal_relocs; irel < irelend; irel++)
3878     {
3879       bfd_vma symval;
3880       struct alpha_elf_got_entry *gotent;
3881       unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3882       unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3883
3884       /* Early exit for unhandled or unrelaxable relocations.  */
3885       if (r_type != R_ALPHA_LITERAL)
3886         {
3887           /* We complete everything except LITERAL in the first pass.  */
3888           if (relax_pass != 0)
3889             continue;
3890           if (r_type == R_ALPHA_TLSLDM)
3891             {
3892               /* The symbol for a TLSLDM reloc is ignored.  Collapse the
3893                  reloc to the STN_UNDEF (0) symbol so that they all match.  */
3894               r_symndx = STN_UNDEF;
3895             }
3896           else if (r_type != R_ALPHA_GOTDTPREL
3897                    && r_type != R_ALPHA_GOTTPREL
3898                    && r_type != R_ALPHA_TLSGD)
3899             continue;
3900         }
3901
3902       /* Get the value of the symbol referred to by the reloc.  */
3903       if (r_symndx < symtab_hdr->sh_info)
3904         {
3905           /* A local symbol.  */
3906           Elf_Internal_Sym *isym;
3907
3908           /* Read this BFD's local symbols.  */
3909           if (isymbuf == NULL)
3910             {
3911               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3912               if (isymbuf == NULL)
3913                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3914                                                 symtab_hdr->sh_info, 0,
3915                                                 NULL, NULL, NULL);
3916               if (isymbuf == NULL)
3917                 goto error_return;
3918             }
3919
3920           isym = isymbuf + r_symndx;
3921
3922           /* Given the symbol for a TLSLDM reloc is ignored, this also
3923              means forcing the symbol value to the tp base.  */
3924           if (r_type == R_ALPHA_TLSLDM)
3925             {
3926               info.tsec = bfd_abs_section_ptr;
3927               symval = alpha_get_tprel_base (info.link_info);
3928             }
3929           else
3930             {
3931               symval = isym->st_value;
3932               if (isym->st_shndx == SHN_UNDEF)
3933                 continue;
3934               else if (isym->st_shndx == SHN_ABS)
3935                 info.tsec = bfd_abs_section_ptr;
3936               else if (isym->st_shndx == SHN_COMMON)
3937                 info.tsec = bfd_com_section_ptr;
3938               else
3939                 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3940             }
3941
3942           info.h = NULL;
3943           info.other = isym->st_other;
3944           if (local_got_entries)
3945             info.first_gotent = &local_got_entries[r_symndx];
3946           else
3947             {
3948               info.first_gotent = &info.gotent;
3949               info.gotent = NULL;
3950             }
3951         }
3952       else
3953         {
3954           unsigned long indx;
3955           struct alpha_elf_link_hash_entry *h;
3956
3957           indx = r_symndx - symtab_hdr->sh_info;
3958           h = alpha_elf_sym_hashes (abfd)[indx];
3959           BFD_ASSERT (h != NULL);
3960
3961           while (h->root.root.type == bfd_link_hash_indirect
3962                  || h->root.root.type == bfd_link_hash_warning)
3963             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3964
3965           /* If the symbol is undefined, we can't do anything with it.  */
3966           if (h->root.root.type == bfd_link_hash_undefined)
3967             continue;
3968
3969           /* If the symbol isn't defined in the current module,
3970              again we can't do anything.  */
3971           if (h->root.root.type == bfd_link_hash_undefweak)
3972             {
3973               info.tsec = bfd_abs_section_ptr;
3974               symval = 0;
3975             }
3976           else if (!h->root.def_regular)
3977             {
3978               /* Except for TLSGD relocs, which can sometimes be
3979                  relaxed to GOTTPREL relocs.  */
3980               if (r_type != R_ALPHA_TLSGD)
3981                 continue;
3982               info.tsec = bfd_abs_section_ptr;
3983               symval = 0;
3984             }
3985           else
3986             {
3987               info.tsec = h->root.root.u.def.section;
3988               symval = h->root.root.u.def.value;
3989             }
3990
3991           info.h = h;
3992           info.other = h->root.other;
3993           info.first_gotent = &h->got_entries;
3994         }
3995
3996       /* Search for the got entry to be used by this relocation.  */
3997       for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3998         if (gotent->gotobj == info.gotobj
3999             && gotent->reloc_type == r_type
4000             && gotent->addend == irel->r_addend)
4001           break;
4002       info.gotent = gotent;
4003
4004       symval += info.tsec->output_section->vma + info.tsec->output_offset;
4005       symval += irel->r_addend;
4006
4007       switch (r_type)
4008         {
4009         case R_ALPHA_LITERAL:
4010           BFD_ASSERT(info.gotent != NULL);
4011
4012           /* If there exist LITUSE relocations immediately following, this
4013              opens up all sorts of interesting optimizations, because we
4014              now know every location that this address load is used.  */
4015           if (irel+1 < irelend
4016               && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
4017             {
4018               if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
4019                 goto error_return;
4020             }
4021           else
4022             {
4023               if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
4024                 goto error_return;
4025             }
4026           break;
4027
4028         case R_ALPHA_GOTDTPREL:
4029         case R_ALPHA_GOTTPREL:
4030           BFD_ASSERT(info.gotent != NULL);
4031           if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
4032             goto error_return;
4033           break;
4034
4035         case R_ALPHA_TLSGD:
4036         case R_ALPHA_TLSLDM:
4037           BFD_ASSERT(info.gotent != NULL);
4038           if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
4039                                                r_type == R_ALPHA_TLSGD))
4040             goto error_return;
4041           break;
4042         }
4043     }
4044
4045   if (isymbuf != NULL
4046       && symtab_hdr->contents != (unsigned char *) isymbuf)
4047     {
4048       if (!link_info->keep_memory)
4049         free (isymbuf);
4050       else
4051         {
4052           /* Cache the symbols for elf_link_input_bfd.  */
4053           symtab_hdr->contents = (unsigned char *) isymbuf;
4054         }
4055     }
4056
4057   if (info.contents != NULL
4058       && elf_section_data (sec)->this_hdr.contents != info.contents)
4059     {
4060       if (!info.changed_contents && !link_info->keep_memory)
4061         free (info.contents);
4062       else
4063         {
4064           /* Cache the section contents for elf_link_input_bfd.  */
4065           elf_section_data (sec)->this_hdr.contents = info.contents;
4066         }
4067     }
4068
4069   if (elf_section_data (sec)->relocs != internal_relocs)
4070     {
4071       if (!info.changed_relocs)
4072         free (internal_relocs);
4073       else
4074         elf_section_data (sec)->relocs = internal_relocs;
4075     }
4076
4077   *again = info.changed_contents || info.changed_relocs;
4078
4079   return TRUE;
4080
4081  error_return:
4082   if (isymbuf != NULL
4083       && symtab_hdr->contents != (unsigned char *) isymbuf)
4084     free (isymbuf);
4085   if (info.contents != NULL
4086       && elf_section_data (sec)->this_hdr.contents != info.contents)
4087     free (info.contents);
4088   if (internal_relocs != NULL
4089       && elf_section_data (sec)->relocs != internal_relocs)
4090     free (internal_relocs);
4091   return FALSE;
4092 }
4093 \f
4094 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4095    into the next available slot in SREL.  */
4096
4097 static void
4098 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4099                          asection *sec, asection *srel, bfd_vma offset,
4100                          long dynindx, long rtype, bfd_vma addend)
4101 {
4102   Elf_Internal_Rela outrel;
4103   bfd_byte *loc;
4104
4105   BFD_ASSERT (srel != NULL);
4106
4107   outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4108   outrel.r_addend = addend;
4109
4110   offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4111   if ((offset | 1) != (bfd_vma) -1)
4112     outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4113   else
4114     memset (&outrel, 0, sizeof (outrel));
4115
4116   loc = srel->contents;
4117   loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4118   bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4119   BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4120 }
4121
4122 /* Relocate an Alpha ELF section for a relocatable link.
4123
4124    We don't have to change anything unless the reloc is against a section
4125    symbol, in which case we have to adjust according to where the section
4126    symbol winds up in the output section.  */
4127
4128 static bfd_boolean
4129 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4130                                 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4131                                 bfd *input_bfd, asection *input_section,
4132                                 bfd_byte *contents ATTRIBUTE_UNUSED,
4133                                 Elf_Internal_Rela *relocs,
4134                                 Elf_Internal_Sym *local_syms,
4135                                 asection **local_sections)
4136 {
4137   unsigned long symtab_hdr_sh_info;
4138   Elf_Internal_Rela *rel;
4139   Elf_Internal_Rela *relend;
4140   struct elf_link_hash_entry **sym_hashes;
4141   bfd_boolean ret_val = TRUE;
4142
4143   symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4144   sym_hashes = elf_sym_hashes (input_bfd);
4145
4146   relend = relocs + input_section->reloc_count;
4147   for (rel = relocs; rel < relend; rel++)
4148     {
4149       unsigned long r_symndx;
4150       Elf_Internal_Sym *sym;
4151       asection *sec;
4152       unsigned long r_type;
4153
4154       r_type = ELF64_R_TYPE (rel->r_info);
4155       if (r_type >= R_ALPHA_max)
4156         {
4157           _bfd_error_handler
4158             /* xgettext:c-format */
4159             (_("%B: unknown relocation type %d"),
4160              input_bfd, (int) r_type);
4161           bfd_set_error (bfd_error_bad_value);
4162           ret_val = FALSE;
4163           continue;
4164         }
4165
4166       /* The symbol associated with GPDISP and LITUSE is
4167          immaterial.  Only the addend is significant.  */
4168       if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4169         continue;
4170
4171       r_symndx = ELF64_R_SYM (rel->r_info);
4172       if (r_symndx < symtab_hdr_sh_info)
4173         {
4174           sym = local_syms + r_symndx;
4175           sec = local_sections[r_symndx];
4176         }
4177       else
4178         {
4179           struct elf_link_hash_entry *h;
4180
4181           h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4182
4183           while (h->root.type == bfd_link_hash_indirect
4184                  || h->root.type == bfd_link_hash_warning)
4185             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4186
4187           if (h->root.type != bfd_link_hash_defined
4188               && h->root.type != bfd_link_hash_defweak)
4189             continue;
4190
4191           sym = NULL;
4192           sec = h->root.u.def.section;
4193         }
4194
4195       if (sec != NULL && discarded_section (sec))
4196         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4197                                          rel, 1, relend,
4198                                          elf64_alpha_howto_table + r_type, 0,
4199                                          contents);
4200
4201       if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4202         rel->r_addend += sec->output_offset;
4203     }
4204
4205   return ret_val;
4206 }
4207
4208 /* Relocate an Alpha ELF section.  */
4209
4210 static bfd_boolean
4211 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4212                               bfd *input_bfd, asection *input_section,
4213                               bfd_byte *contents, Elf_Internal_Rela *relocs,
4214                               Elf_Internal_Sym *local_syms,
4215                               asection **local_sections)
4216 {
4217   Elf_Internal_Shdr *symtab_hdr;
4218   Elf_Internal_Rela *rel;
4219   Elf_Internal_Rela *relend;
4220   asection *sgot, *srel, *srelgot;
4221   bfd *dynobj, *gotobj;
4222   bfd_vma gp, tp_base, dtp_base;
4223   struct alpha_elf_got_entry **local_got_entries;
4224   bfd_boolean ret_val;
4225
4226   BFD_ASSERT (is_alpha_elf (input_bfd));
4227
4228   /* Handle relocatable links with a smaller loop.  */
4229   if (bfd_link_relocatable (info))
4230     return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4231                                            input_section, contents, relocs,
4232                                            local_syms, local_sections);
4233
4234   /* This is a final link.  */
4235
4236   ret_val = TRUE;
4237
4238   symtab_hdr = &elf_symtab_hdr (input_bfd);
4239
4240   dynobj = elf_hash_table (info)->dynobj;
4241   srelgot = elf_hash_table (info)->srelgot;
4242
4243   if (input_section->flags & SEC_ALLOC)
4244     {
4245       const char *section_name;
4246       section_name = (bfd_elf_string_from_elf_section
4247                       (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4248                        _bfd_elf_single_rel_hdr (input_section)->sh_name));
4249       BFD_ASSERT(section_name != NULL);
4250       srel = bfd_get_linker_section (dynobj, section_name);
4251     }
4252   else
4253     srel = NULL;
4254
4255   /* Find the gp value for this input bfd.  */
4256   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4257   if (gotobj)
4258     {
4259       sgot = alpha_elf_tdata (gotobj)->got;
4260       gp = _bfd_get_gp_value (gotobj);
4261       if (gp == 0)
4262         {
4263           gp = (sgot->output_section->vma
4264                 + sgot->output_offset
4265                 + 0x8000);
4266           _bfd_set_gp_value (gotobj, gp);
4267         }
4268     }
4269   else
4270     {
4271       sgot = NULL;
4272       gp = 0;
4273     }
4274
4275   local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4276
4277   if (elf_hash_table (info)->tls_sec != NULL)
4278     {
4279       dtp_base = alpha_get_dtprel_base (info);
4280       tp_base = alpha_get_tprel_base (info);
4281     }
4282   else
4283     dtp_base = tp_base = 0;
4284
4285   relend = relocs + input_section->reloc_count;
4286   for (rel = relocs; rel < relend; rel++)
4287     {
4288       struct alpha_elf_link_hash_entry *h = NULL;
4289       struct alpha_elf_got_entry *gotent;
4290       bfd_reloc_status_type r;
4291       reloc_howto_type *howto;
4292       unsigned long r_symndx;
4293       Elf_Internal_Sym *sym = NULL;
4294       asection *sec = NULL;
4295       bfd_vma value;
4296       bfd_vma addend;
4297       bfd_boolean dynamic_symbol_p;
4298       bfd_boolean unresolved_reloc = FALSE;
4299       bfd_boolean undef_weak_ref = FALSE;
4300       unsigned long r_type;
4301
4302       r_type = ELF64_R_TYPE(rel->r_info);
4303       if (r_type >= R_ALPHA_max)
4304         {
4305           _bfd_error_handler
4306             /* xgettext:c-format */
4307             (_("%B: unknown relocation type %d"),
4308              input_bfd, (int) r_type);
4309           bfd_set_error (bfd_error_bad_value);
4310           ret_val = FALSE;
4311           continue;
4312         }
4313
4314       howto = elf64_alpha_howto_table + r_type;
4315       r_symndx = ELF64_R_SYM(rel->r_info);
4316
4317       /* The symbol for a TLSLDM reloc is ignored.  Collapse the
4318          reloc to the STN_UNDEF (0) symbol so that they all match.  */
4319       if (r_type == R_ALPHA_TLSLDM)
4320         r_symndx = STN_UNDEF;
4321
4322       if (r_symndx < symtab_hdr->sh_info)
4323         {
4324           asection *msec;
4325           sym = local_syms + r_symndx;
4326           sec = local_sections[r_symndx];
4327           msec = sec;
4328           value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4329
4330           /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4331              this is hackery from relax_section.  Force the value to
4332              be the tls module base.  */
4333           if (r_symndx == STN_UNDEF
4334               && (r_type == R_ALPHA_TLSLDM
4335                   || r_type == R_ALPHA_GOTTPREL
4336                   || r_type == R_ALPHA_TPREL64
4337                   || r_type == R_ALPHA_TPRELHI
4338                   || r_type == R_ALPHA_TPRELLO
4339                   || r_type == R_ALPHA_TPREL16))
4340             value = dtp_base;
4341
4342           if (local_got_entries)
4343             gotent = local_got_entries[r_symndx];
4344           else
4345             gotent = NULL;
4346
4347           /* Need to adjust local GOT entries' addends for SEC_MERGE
4348              unless it has been done already.  */
4349           if ((sec->flags & SEC_MERGE)
4350               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4351               && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4352               && gotent
4353               && !gotent->reloc_xlated)
4354             {
4355               struct alpha_elf_got_entry *ent;
4356
4357               for (ent = gotent; ent; ent = ent->next)
4358                 {
4359                   ent->reloc_xlated = 1;
4360                   if (ent->use_count == 0)
4361                     continue;
4362                   msec = sec;
4363                   ent->addend =
4364                     _bfd_merged_section_offset (output_bfd, &msec,
4365                                                 elf_section_data (sec)->
4366                                                   sec_info,
4367                                                 sym->st_value + ent->addend);
4368                   ent->addend -= sym->st_value;
4369                   ent->addend += msec->output_section->vma
4370                                  + msec->output_offset
4371                                  - sec->output_section->vma
4372                                  - sec->output_offset;
4373                 }
4374             }
4375
4376           dynamic_symbol_p = FALSE;
4377         }
4378       else
4379         {
4380           bfd_boolean warned, ignored;
4381           struct elf_link_hash_entry *hh;
4382           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4383
4384           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4385                                    r_symndx, symtab_hdr, sym_hashes,
4386                                    hh, sec, value,
4387                                    unresolved_reloc, warned, ignored);
4388
4389           if (warned)
4390             continue;
4391
4392           if (value == 0
4393               && ! unresolved_reloc
4394               && hh->root.type == bfd_link_hash_undefweak)
4395             undef_weak_ref = TRUE;
4396
4397           h = (struct alpha_elf_link_hash_entry *) hh;
4398           dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4399           gotent = h->got_entries;
4400         }
4401
4402       if (sec != NULL && discarded_section (sec))
4403         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4404                                          rel, 1, relend, howto, 0, contents);
4405
4406       addend = rel->r_addend;
4407       value += addend;
4408
4409       /* Search for the proper got entry.  */
4410       for (; gotent ; gotent = gotent->next)
4411         if (gotent->gotobj == gotobj
4412             && gotent->reloc_type == r_type
4413             && gotent->addend == addend)
4414           break;
4415
4416       switch (r_type)
4417         {
4418         case R_ALPHA_GPDISP:
4419           {
4420             bfd_byte *p_ldah, *p_lda;
4421
4422             BFD_ASSERT(gp != 0);
4423
4424             value = (input_section->output_section->vma
4425                      + input_section->output_offset
4426                      + rel->r_offset);
4427
4428             p_ldah = contents + rel->r_offset;
4429             p_lda = p_ldah + rel->r_addend;
4430
4431             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4432                                              p_ldah, p_lda);
4433           }
4434           break;
4435
4436         case R_ALPHA_LITERAL:
4437           BFD_ASSERT(sgot != NULL);
4438           BFD_ASSERT(gp != 0);
4439           BFD_ASSERT(gotent != NULL);
4440           BFD_ASSERT(gotent->use_count >= 1);
4441
4442           if (!gotent->reloc_done)
4443             {
4444               gotent->reloc_done = 1;
4445
4446               bfd_put_64 (output_bfd, value,
4447                           sgot->contents + gotent->got_offset);
4448
4449               /* If the symbol has been forced local, output a
4450                  RELATIVE reloc, otherwise it will be handled in
4451                  finish_dynamic_symbol.  */
4452               if (bfd_link_pic (info)
4453                   && !dynamic_symbol_p
4454                   && !undef_weak_ref)
4455                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4456                                          gotent->got_offset, 0,
4457                                          R_ALPHA_RELATIVE, value);
4458             }
4459
4460           value = (sgot->output_section->vma
4461                    + sgot->output_offset
4462                    + gotent->got_offset);
4463           value -= gp;
4464           goto default_reloc;
4465
4466         case R_ALPHA_GPREL32:
4467         case R_ALPHA_GPREL16:
4468         case R_ALPHA_GPRELLOW:
4469           if (dynamic_symbol_p)
4470             {
4471               _bfd_error_handler
4472                 /* xgettext:c-format */
4473                 (_("%B: gp-relative relocation against dynamic symbol %s"),
4474                  input_bfd, h->root.root.root.string);
4475               ret_val = FALSE;
4476             }
4477           BFD_ASSERT(gp != 0);
4478           value -= gp;
4479           goto default_reloc;
4480
4481         case R_ALPHA_GPRELHIGH:
4482           if (dynamic_symbol_p)
4483             {
4484               _bfd_error_handler
4485                 /* xgettext:c-format */
4486                 (_("%B: gp-relative relocation against dynamic symbol %s"),
4487                  input_bfd, h->root.root.root.string);
4488               ret_val = FALSE;
4489             }
4490           BFD_ASSERT(gp != 0);
4491           value -= gp;
4492           value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4493           goto default_reloc;
4494
4495         case R_ALPHA_HINT:
4496           /* A call to a dynamic symbol is definitely out of range of
4497              the 16-bit displacement.  Don't bother writing anything.  */
4498           if (dynamic_symbol_p)
4499             {
4500               r = bfd_reloc_ok;
4501               break;
4502             }
4503           /* The regular PC-relative stuff measures from the start of
4504              the instruction rather than the end.  */
4505           value -= 4;
4506           goto default_reloc;
4507
4508         case R_ALPHA_BRADDR:
4509           if (dynamic_symbol_p)
4510             {
4511               _bfd_error_handler
4512                 /* xgettext:c-format */
4513                 (_("%B: pc-relative relocation against dynamic symbol %s"),
4514                  input_bfd, h->root.root.root.string);
4515               ret_val = FALSE;
4516             }
4517           /* The regular PC-relative stuff measures from the start of
4518              the instruction rather than the end.  */
4519           value -= 4;
4520           goto default_reloc;
4521
4522         case R_ALPHA_BRSGP:
4523           {
4524             int other;
4525             const char *name;
4526
4527             /* The regular PC-relative stuff measures from the start of
4528                the instruction rather than the end.  */
4529             value -= 4;
4530
4531             /* The source and destination gp must be the same.  Note that
4532                the source will always have an assigned gp, since we forced
4533                one in check_relocs, but that the destination may not, as
4534                it might not have had any relocations at all.  Also take
4535                care not to crash if H is an undefined symbol.  */
4536             if (h != NULL && sec != NULL
4537                 && alpha_elf_tdata (sec->owner)->gotobj
4538                 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4539               {
4540                 _bfd_error_handler
4541                   /* xgettext:c-format */
4542                   (_("%B: change in gp: BRSGP %s"),
4543                    input_bfd, h->root.root.root.string);
4544                 ret_val = FALSE;
4545               }
4546
4547             /* The symbol should be marked either NOPV or STD_GPLOAD.  */
4548             if (h != NULL)
4549               other = h->root.other;
4550             else
4551               other = sym->st_other;
4552             switch (other & STO_ALPHA_STD_GPLOAD)
4553               {
4554               case STO_ALPHA_NOPV:
4555                 break;
4556               case STO_ALPHA_STD_GPLOAD:
4557                 value += 8;
4558                 break;
4559               default:
4560                 if (h != NULL)
4561                   name = h->root.root.root.string;
4562                 else
4563                   {
4564                     name = (bfd_elf_string_from_elf_section
4565                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
4566                     if (name == NULL)
4567                       name = _("<unknown>");
4568                     else if (name[0] == 0)
4569                       name = bfd_section_name (input_bfd, sec);
4570                   }
4571                 _bfd_error_handler
4572                   /* xgettext:c-format */
4573                   (_("%B: !samegp reloc against symbol without .prologue: %s"),
4574                    input_bfd, name);
4575                 ret_val = FALSE;
4576                 break;
4577               }
4578
4579             goto default_reloc;
4580           }
4581
4582         case R_ALPHA_REFLONG:
4583         case R_ALPHA_REFQUAD:
4584         case R_ALPHA_DTPREL64:
4585         case R_ALPHA_TPREL64:
4586           {
4587             long dynindx, dyntype = r_type;
4588             bfd_vma dynaddend;
4589
4590             /* Careful here to remember RELATIVE relocations for global
4591                variables for symbolic shared objects.  */
4592
4593             if (dynamic_symbol_p)
4594               {
4595                 BFD_ASSERT(h->root.dynindx != -1);
4596                 dynindx = h->root.dynindx;
4597                 dynaddend = addend;
4598                 addend = 0, value = 0;
4599               }
4600             else if (r_type == R_ALPHA_DTPREL64)
4601               {
4602                 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4603                 value -= dtp_base;
4604                 goto default_reloc;
4605               }
4606             else if (r_type == R_ALPHA_TPREL64)
4607               {
4608                 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4609                 if (!bfd_link_dll (info))
4610                   {
4611                     value -= tp_base;
4612                     goto default_reloc;
4613                   }
4614                 dynindx = 0;
4615                 dynaddend = value - dtp_base;
4616               }
4617             else if (bfd_link_pic (info)
4618                      && r_symndx != STN_UNDEF
4619                      && (input_section->flags & SEC_ALLOC)
4620                      && !undef_weak_ref
4621                      && !(unresolved_reloc
4622                           && (_bfd_elf_section_offset (output_bfd, info,
4623                                                        input_section,
4624                                                        rel->r_offset)
4625                               == (bfd_vma) -1)))
4626               {
4627                 if (r_type == R_ALPHA_REFLONG)
4628                   {
4629                     _bfd_error_handler
4630                       /* xgettext:c-format */
4631                       (_("%B: unhandled dynamic relocation against %s"),
4632                        input_bfd,
4633                        h->root.root.root.string);
4634                     ret_val = FALSE;
4635                   }
4636                 dynindx = 0;
4637                 dyntype = R_ALPHA_RELATIVE;
4638                 dynaddend = value;
4639               }
4640             else
4641               goto default_reloc;
4642
4643             if (input_section->flags & SEC_ALLOC)
4644               elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4645                                        srel, rel->r_offset, dynindx,
4646                                        dyntype, dynaddend);
4647           }
4648           goto default_reloc;
4649
4650         case R_ALPHA_SREL16:
4651         case R_ALPHA_SREL32:
4652         case R_ALPHA_SREL64:
4653           if (dynamic_symbol_p)
4654             {
4655               _bfd_error_handler
4656                 /* xgettext:c-format */
4657                 (_("%B: pc-relative relocation against dynamic symbol %s"),
4658                  input_bfd, h->root.root.root.string);
4659               ret_val = FALSE;
4660             }
4661           else if (bfd_link_pic (info)
4662                    && undef_weak_ref)
4663             {
4664               _bfd_error_handler
4665                 /* xgettext:c-format */
4666                 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4667                  input_bfd, h->root.root.root.string);
4668               ret_val = FALSE;
4669             }
4670
4671
4672           /* ??? .eh_frame references to discarded sections will be smashed
4673              to relocations against SHN_UNDEF.  The .eh_frame format allows
4674              NULL to be encoded as 0 in any format, so this works here.  */
4675           if (r_symndx == STN_UNDEF
4676               || (unresolved_reloc
4677                   && _bfd_elf_section_offset (output_bfd, info,
4678                                               input_section,
4679                                               rel->r_offset) == (bfd_vma) -1))
4680             howto = (elf64_alpha_howto_table
4681                      + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4682           goto default_reloc;
4683
4684         case R_ALPHA_TLSLDM:
4685           /* Ignore the symbol for the relocation.  The result is always
4686              the current module.  */
4687           dynamic_symbol_p = 0;
4688           /* FALLTHRU */
4689
4690         case R_ALPHA_TLSGD:
4691           if (!gotent->reloc_done)
4692             {
4693               gotent->reloc_done = 1;
4694
4695               /* Note that the module index for the main program is 1.  */
4696               bfd_put_64 (output_bfd,
4697                           !bfd_link_pic (info) && !dynamic_symbol_p,
4698                           sgot->contents + gotent->got_offset);
4699
4700               /* If the symbol has been forced local, output a
4701                  DTPMOD64 reloc, otherwise it will be handled in
4702                  finish_dynamic_symbol.  */
4703               if (bfd_link_pic (info) && !dynamic_symbol_p)
4704                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4705                                          gotent->got_offset, 0,
4706                                          R_ALPHA_DTPMOD64, 0);
4707
4708               if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4709                 value = 0;
4710               else
4711                 {
4712                   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4713                   value -= dtp_base;
4714                 }
4715               bfd_put_64 (output_bfd, value,
4716                           sgot->contents + gotent->got_offset + 8);
4717             }
4718
4719           value = (sgot->output_section->vma
4720                    + sgot->output_offset
4721                    + gotent->got_offset);
4722           value -= gp;
4723           goto default_reloc;
4724
4725         case R_ALPHA_DTPRELHI:
4726         case R_ALPHA_DTPRELLO:
4727         case R_ALPHA_DTPREL16:
4728           if (dynamic_symbol_p)
4729             {
4730               _bfd_error_handler
4731                 /* xgettext:c-format */
4732                 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4733                  input_bfd, h->root.root.root.string);
4734               ret_val = FALSE;
4735             }
4736           BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4737           value -= dtp_base;
4738           if (r_type == R_ALPHA_DTPRELHI)
4739             value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4740           goto default_reloc;
4741
4742         case R_ALPHA_TPRELHI:
4743         case R_ALPHA_TPRELLO:
4744         case R_ALPHA_TPREL16:
4745           if (bfd_link_dll (info))
4746             {
4747               _bfd_error_handler
4748                 /* xgettext:c-format */
4749                 (_("%B: TLS local exec code cannot be linked into shared objects"),
4750                 input_bfd);
4751               ret_val = FALSE;
4752             }
4753           else if (dynamic_symbol_p)
4754             {
4755               _bfd_error_handler
4756                 /* xgettext:c-format */
4757                 (_("%B: tp-relative relocation against dynamic symbol %s"),
4758                  input_bfd, h->root.root.root.string);
4759               ret_val = FALSE;
4760             }
4761           BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4762           value -= tp_base;
4763           if (r_type == R_ALPHA_TPRELHI)
4764             value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4765           goto default_reloc;
4766
4767         case R_ALPHA_GOTDTPREL:
4768         case R_ALPHA_GOTTPREL:
4769           BFD_ASSERT(sgot != NULL);
4770           BFD_ASSERT(gp != 0);
4771           BFD_ASSERT(gotent != NULL);
4772           BFD_ASSERT(gotent->use_count >= 1);
4773
4774           if (!gotent->reloc_done)
4775             {
4776               gotent->reloc_done = 1;
4777
4778               if (dynamic_symbol_p)
4779                 value = 0;
4780               else
4781                 {
4782                   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4783                   if (r_type == R_ALPHA_GOTDTPREL)
4784                     value -= dtp_base;
4785                   else if (!bfd_link_pic (info))
4786                     value -= tp_base;
4787                   else
4788                     {
4789                       elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4790                                                gotent->got_offset, 0,
4791                                                R_ALPHA_TPREL64,
4792                                                value - dtp_base);
4793                       value = 0;
4794                     }
4795                 }
4796               bfd_put_64 (output_bfd, value,
4797                           sgot->contents + gotent->got_offset);
4798             }
4799
4800           value = (sgot->output_section->vma
4801                    + sgot->output_offset
4802                    + gotent->got_offset);
4803           value -= gp;
4804           goto default_reloc;
4805
4806         default:
4807         default_reloc:
4808           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4809                                         contents, rel->r_offset, value, 0);
4810           break;
4811         }
4812
4813       switch (r)
4814         {
4815         case bfd_reloc_ok:
4816           break;
4817
4818         case bfd_reloc_overflow:
4819           {
4820             const char *name;
4821
4822             /* Don't warn if the overflow is due to pc relative reloc
4823                against discarded section.  Section optimization code should
4824                handle it.  */
4825
4826             if (r_symndx < symtab_hdr->sh_info
4827                 && sec != NULL && howto->pc_relative
4828                 && discarded_section (sec))
4829               break;
4830
4831             if (h != NULL)
4832               name = NULL;
4833             else
4834               {
4835                 name = (bfd_elf_string_from_elf_section
4836                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
4837                 if (name == NULL)
4838                   return FALSE;
4839                 if (*name == '\0')
4840                   name = bfd_section_name (input_bfd, sec);
4841               }
4842             (*info->callbacks->reloc_overflow)
4843               (info, (h ? &h->root.root : NULL), name, howto->name,
4844                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4845           }
4846           break;
4847
4848         default:
4849         case bfd_reloc_outofrange:
4850           abort ();
4851         }
4852     }
4853
4854   return ret_val;
4855 }
4856
4857 /* Finish up dynamic symbol handling.  We set the contents of various
4858    dynamic sections here.  */
4859
4860 static bfd_boolean
4861 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4862                                    struct elf_link_hash_entry *h,
4863                                    Elf_Internal_Sym *sym)
4864 {
4865   struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4866
4867   if (h->needs_plt)
4868     {
4869       /* Fill in the .plt entry for this symbol.  */
4870       asection *splt, *sgot, *srel;
4871       Elf_Internal_Rela outrel;
4872       bfd_byte *loc;
4873       bfd_vma got_addr, plt_addr;
4874       bfd_vma plt_index;
4875       struct alpha_elf_got_entry *gotent;
4876
4877       BFD_ASSERT (h->dynindx != -1);
4878
4879       splt = elf_hash_table (info)->splt;
4880       BFD_ASSERT (splt != NULL);
4881       srel = elf_hash_table (info)->srelplt;
4882       BFD_ASSERT (srel != NULL);
4883
4884       for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4885         if (gotent->reloc_type == R_ALPHA_LITERAL
4886             && gotent->use_count > 0)
4887           {
4888             unsigned int insn;
4889             int disp;
4890
4891             sgot = alpha_elf_tdata (gotent->gotobj)->got;
4892             BFD_ASSERT (sgot != NULL);
4893
4894             BFD_ASSERT (gotent->got_offset != -1);
4895             BFD_ASSERT (gotent->plt_offset != -1);
4896
4897             got_addr = (sgot->output_section->vma
4898                         + sgot->output_offset
4899                         + gotent->got_offset);
4900             plt_addr = (splt->output_section->vma
4901                         + splt->output_offset
4902                         + gotent->plt_offset);
4903
4904             plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4905
4906             /* Fill in the entry in the procedure linkage table.  */
4907             if (elf64_alpha_use_secureplt)
4908               {
4909                 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4910                 insn = INSN_AD (INSN_BR, 31, disp);
4911                 bfd_put_32 (output_bfd, insn,
4912                             splt->contents + gotent->plt_offset);
4913
4914                 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4915                              / NEW_PLT_ENTRY_SIZE);
4916               }
4917             else
4918               {
4919                 disp = -(gotent->plt_offset + 4);
4920                 insn = INSN_AD (INSN_BR, 28, disp);
4921                 bfd_put_32 (output_bfd, insn,
4922                             splt->contents + gotent->plt_offset);
4923                 bfd_put_32 (output_bfd, INSN_UNOP,
4924                             splt->contents + gotent->plt_offset + 4);
4925                 bfd_put_32 (output_bfd, INSN_UNOP,
4926                             splt->contents + gotent->plt_offset + 8);
4927
4928                 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4929                              / OLD_PLT_ENTRY_SIZE);
4930               }
4931
4932             /* Fill in the entry in the .rela.plt section.  */
4933             outrel.r_offset = got_addr;
4934             outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4935             outrel.r_addend = 0;
4936
4937             loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4938             bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4939
4940             /* Fill in the entry in the .got.  */
4941             bfd_put_64 (output_bfd, plt_addr,
4942                         sgot->contents + gotent->got_offset);
4943           }
4944     }
4945   else if (alpha_elf_dynamic_symbol_p (h, info))
4946     {
4947       /* Fill in the dynamic relocations for this symbol's .got entries.  */
4948       asection *srel;
4949       struct alpha_elf_got_entry *gotent;
4950
4951       srel = elf_hash_table (info)->srelgot;
4952       BFD_ASSERT (srel != NULL);
4953
4954       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4955            gotent != NULL;
4956            gotent = gotent->next)
4957         {
4958           asection *sgot;
4959           long r_type;
4960
4961           if (gotent->use_count == 0)
4962             continue;
4963
4964           sgot = alpha_elf_tdata (gotent->gotobj)->got;
4965
4966           r_type = gotent->reloc_type;
4967           switch (r_type)
4968             {
4969             case R_ALPHA_LITERAL:
4970               r_type = R_ALPHA_GLOB_DAT;
4971               break;
4972             case R_ALPHA_TLSGD:
4973               r_type = R_ALPHA_DTPMOD64;
4974               break;
4975             case R_ALPHA_GOTDTPREL:
4976               r_type = R_ALPHA_DTPREL64;
4977               break;
4978             case R_ALPHA_GOTTPREL:
4979               r_type = R_ALPHA_TPREL64;
4980               break;
4981             case R_ALPHA_TLSLDM:
4982             default:
4983               abort ();
4984             }
4985
4986           elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4987                                    gotent->got_offset, h->dynindx,
4988                                    r_type, gotent->addend);
4989
4990           if (gotent->reloc_type == R_ALPHA_TLSGD)
4991             elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4992                                      gotent->got_offset + 8, h->dynindx,
4993                                      R_ALPHA_DTPREL64, gotent->addend);
4994         }
4995     }
4996
4997   /* Mark some specially defined symbols as absolute.  */
4998   if (h == elf_hash_table (info)->hdynamic
4999       || h == elf_hash_table (info)->hgot
5000       || h == elf_hash_table (info)->hplt)
5001     sym->st_shndx = SHN_ABS;
5002
5003   return TRUE;
5004 }
5005
5006 /* Finish up the dynamic sections.  */
5007
5008 static bfd_boolean
5009 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
5010                                      struct bfd_link_info *info)
5011 {
5012   bfd *dynobj;
5013   asection *sdyn;
5014
5015   dynobj = elf_hash_table (info)->dynobj;
5016   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5017
5018   if (elf_hash_table (info)->dynamic_sections_created)
5019     {
5020       asection *splt, *sgotplt, *srelaplt;
5021       Elf64_External_Dyn *dyncon, *dynconend;
5022       bfd_vma plt_vma, gotplt_vma;
5023
5024       splt = elf_hash_table (info)->splt;
5025       srelaplt = elf_hash_table (info)->srelplt;
5026       BFD_ASSERT (splt != NULL && sdyn != NULL);
5027
5028       plt_vma = splt->output_section->vma + splt->output_offset;
5029
5030       gotplt_vma = 0;
5031       if (elf64_alpha_use_secureplt)
5032         {
5033           sgotplt = elf_hash_table (info)->sgotplt;
5034           BFD_ASSERT (sgotplt != NULL);
5035           if (sgotplt->size > 0)
5036             gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
5037         }
5038
5039       dyncon = (Elf64_External_Dyn *) sdyn->contents;
5040       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5041       for (; dyncon < dynconend; dyncon++)
5042         {
5043           Elf_Internal_Dyn dyn;
5044
5045           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5046
5047           switch (dyn.d_tag)
5048             {
5049             case DT_PLTGOT:
5050               dyn.d_un.d_ptr
5051                 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
5052               break;
5053             case DT_PLTRELSZ:
5054               dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
5055               break;
5056             case DT_JMPREL:
5057               dyn.d_un.d_ptr = srelaplt ? (srelaplt->output_section->vma
5058                                            + srelaplt->output_offset) : 0;
5059               break;
5060             }
5061
5062           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5063         }
5064
5065       /* Initialize the plt header.  */
5066       if (splt->size > 0)
5067         {
5068           unsigned int insn;
5069           int ofs;
5070
5071           if (elf64_alpha_use_secureplt)
5072             {
5073               ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
5074
5075               insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
5076               bfd_put_32 (output_bfd, insn, splt->contents);
5077
5078               insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
5079               bfd_put_32 (output_bfd, insn, splt->contents + 4);
5080
5081               insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
5082               bfd_put_32 (output_bfd, insn, splt->contents + 8);
5083
5084               insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5085               bfd_put_32 (output_bfd, insn, splt->contents + 12);
5086
5087               insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5088               bfd_put_32 (output_bfd, insn, splt->contents + 16);
5089
5090               insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5091               bfd_put_32 (output_bfd, insn, splt->contents + 20);
5092
5093               insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5094               bfd_put_32 (output_bfd, insn, splt->contents + 24);
5095
5096               insn = INSN_AB (INSN_JMP, 31, 27);
5097               bfd_put_32 (output_bfd, insn, splt->contents + 28);
5098
5099               insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5100               bfd_put_32 (output_bfd, insn, splt->contents + 32);
5101             }
5102           else
5103             {
5104               insn = INSN_AD (INSN_BR, 27, 0);  /* br $27, .+4 */
5105               bfd_put_32 (output_bfd, insn, splt->contents);
5106
5107               insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5108               bfd_put_32 (output_bfd, insn, splt->contents + 4);
5109
5110               insn = INSN_UNOP;
5111               bfd_put_32 (output_bfd, insn, splt->contents + 8);
5112
5113               insn = INSN_AB (INSN_JMP, 27, 27);
5114               bfd_put_32 (output_bfd, insn, splt->contents + 12);
5115
5116               /* The next two words will be filled in by ld.so.  */
5117               bfd_put_64 (output_bfd, 0, splt->contents + 16);
5118               bfd_put_64 (output_bfd, 0, splt->contents + 24);
5119             }
5120
5121           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5122         }
5123     }
5124
5125   return TRUE;
5126 }
5127
5128 /* We need to use a special link routine to handle the .mdebug section.
5129    We need to merge all instances of these sections together, not write
5130    them all out sequentially.  */
5131
5132 static bfd_boolean
5133 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5134 {
5135   asection *o;
5136   struct bfd_link_order *p;
5137   asection *mdebug_sec;
5138   struct ecoff_debug_info debug;
5139   const struct ecoff_debug_swap *swap
5140     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5141   HDRR *symhdr = &debug.symbolic_header;
5142   void * mdebug_handle = NULL;
5143   struct alpha_elf_link_hash_table * htab;
5144
5145   htab = alpha_elf_hash_table (info);
5146   if (htab == NULL)
5147     return FALSE;
5148
5149   /* Go through the sections and collect the mdebug information.  */
5150   mdebug_sec = NULL;
5151   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5152     {
5153       if (strcmp (o->name, ".mdebug") == 0)
5154         {
5155           struct extsym_info einfo;
5156
5157           /* We have found the .mdebug section in the output file.
5158              Look through all the link_orders comprising it and merge
5159              the information together.  */
5160           symhdr->magic = swap->sym_magic;
5161           /* FIXME: What should the version stamp be?  */
5162           symhdr->vstamp = 0;
5163           symhdr->ilineMax = 0;
5164           symhdr->cbLine = 0;
5165           symhdr->idnMax = 0;
5166           symhdr->ipdMax = 0;
5167           symhdr->isymMax = 0;
5168           symhdr->ioptMax = 0;
5169           symhdr->iauxMax = 0;
5170           symhdr->issMax = 0;
5171           symhdr->issExtMax = 0;
5172           symhdr->ifdMax = 0;
5173           symhdr->crfd = 0;
5174           symhdr->iextMax = 0;
5175
5176           /* We accumulate the debugging information itself in the
5177              debug_info structure.  */
5178           debug.line = NULL;
5179           debug.external_dnr = NULL;
5180           debug.external_pdr = NULL;
5181           debug.external_sym = NULL;
5182           debug.external_opt = NULL;
5183           debug.external_aux = NULL;
5184           debug.ss = NULL;
5185           debug.ssext = debug.ssext_end = NULL;
5186           debug.external_fdr = NULL;
5187           debug.external_rfd = NULL;
5188           debug.external_ext = debug.external_ext_end = NULL;
5189
5190           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5191           if (mdebug_handle == NULL)
5192             return FALSE;
5193
5194           if (1)
5195             {
5196               asection *s;
5197               EXTR esym;
5198               bfd_vma last = 0;
5199               unsigned int i;
5200               static const char * const name[] =
5201                 {
5202                   ".text", ".init", ".fini", ".data",
5203                   ".rodata", ".sdata", ".sbss", ".bss"
5204                 };
5205               static const int sc[] = { scText, scInit, scFini, scData,
5206                                           scRData, scSData, scSBss, scBss };
5207
5208               esym.jmptbl = 0;
5209               esym.cobol_main = 0;
5210               esym.weakext = 0;
5211               esym.reserved = 0;
5212               esym.ifd = ifdNil;
5213               esym.asym.iss = issNil;
5214               esym.asym.st = stLocal;
5215               esym.asym.reserved = 0;
5216               esym.asym.index = indexNil;
5217               for (i = 0; i < 8; i++)
5218                 {
5219                   esym.asym.sc = sc[i];
5220                   s = bfd_get_section_by_name (abfd, name[i]);
5221                   if (s != NULL)
5222                     {
5223                       esym.asym.value = s->vma;
5224                       last = s->vma + s->size;
5225                     }
5226                   else
5227                     esym.asym.value = last;
5228
5229                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5230                                                       name[i], &esym))
5231                     return FALSE;
5232                 }
5233             }
5234
5235           for (p = o->map_head.link_order;
5236                p != (struct bfd_link_order *) NULL;
5237                p = p->next)
5238             {
5239               asection *input_section;
5240               bfd *input_bfd;
5241               const struct ecoff_debug_swap *input_swap;
5242               struct ecoff_debug_info input_debug;
5243               char *eraw_src;
5244               char *eraw_end;
5245
5246               if (p->type != bfd_indirect_link_order)
5247                 {
5248                   if (p->type == bfd_data_link_order)
5249                     continue;
5250                   abort ();
5251                 }
5252
5253               input_section = p->u.indirect.section;
5254               input_bfd = input_section->owner;
5255
5256               if (! is_alpha_elf (input_bfd))
5257                 /* I don't know what a non ALPHA ELF bfd would be
5258                    doing with a .mdebug section, but I don't really
5259                    want to deal with it.  */
5260                 continue;
5261
5262               input_swap = (get_elf_backend_data (input_bfd)
5263                             ->elf_backend_ecoff_debug_swap);
5264
5265               BFD_ASSERT (p->size == input_section->size);
5266
5267               /* The ECOFF linking code expects that we have already
5268                  read in the debugging information and set up an
5269                  ecoff_debug_info structure, so we do that now.  */
5270               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5271                                                 &input_debug))
5272                 return FALSE;
5273
5274               if (! (bfd_ecoff_debug_accumulate
5275                      (mdebug_handle, abfd, &debug, swap, input_bfd,
5276                       &input_debug, input_swap, info)))
5277                 return FALSE;
5278
5279               /* Loop through the external symbols.  For each one with
5280                  interesting information, try to find the symbol in
5281                  the linker global hash table and save the information
5282                  for the output external symbols.  */
5283               eraw_src = (char *) input_debug.external_ext;
5284               eraw_end = (eraw_src
5285                           + (input_debug.symbolic_header.iextMax
5286                              * input_swap->external_ext_size));
5287               for (;
5288                    eraw_src < eraw_end;
5289                    eraw_src += input_swap->external_ext_size)
5290                 {
5291                   EXTR ext;
5292                   const char *name;
5293                   struct alpha_elf_link_hash_entry *h;
5294
5295                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5296                   if (ext.asym.sc == scNil
5297                       || ext.asym.sc == scUndefined
5298                       || ext.asym.sc == scSUndefined)
5299                     continue;
5300
5301                   name = input_debug.ssext + ext.asym.iss;
5302                   h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5303                   if (h == NULL || h->esym.ifd != -2)
5304                     continue;
5305
5306                   if (ext.ifd != -1)
5307                     {
5308                       BFD_ASSERT (ext.ifd
5309                                   < input_debug.symbolic_header.ifdMax);
5310                       ext.ifd = input_debug.ifdmap[ext.ifd];
5311                     }
5312
5313                   h->esym = ext;
5314                 }
5315
5316               /* Free up the information we just read.  */
5317               free (input_debug.line);
5318               free (input_debug.external_dnr);
5319               free (input_debug.external_pdr);
5320               free (input_debug.external_sym);
5321               free (input_debug.external_opt);
5322               free (input_debug.external_aux);
5323               free (input_debug.ss);
5324               free (input_debug.ssext);
5325               free (input_debug.external_fdr);
5326               free (input_debug.external_rfd);
5327               free (input_debug.external_ext);
5328
5329               /* Hack: reset the SEC_HAS_CONTENTS flag so that
5330                  elf_link_input_bfd ignores this section.  */
5331               input_section->flags &=~ SEC_HAS_CONTENTS;
5332             }
5333
5334           /* Build the external symbol information.  */
5335           einfo.abfd = abfd;
5336           einfo.info = info;
5337           einfo.debug = &debug;
5338           einfo.swap = swap;
5339           einfo.failed = FALSE;
5340           elf_link_hash_traverse (elf_hash_table (info),
5341                                   elf64_alpha_output_extsym,
5342                                   &einfo);
5343           if (einfo.failed)
5344             return FALSE;
5345
5346           /* Set the size of the .mdebug section.  */
5347           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5348
5349           /* Skip this section later on (I don't think this currently
5350              matters, but someday it might).  */
5351           o->map_head.link_order = (struct bfd_link_order *) NULL;
5352
5353           mdebug_sec = o;
5354         }
5355     }
5356
5357   /* Invoke the regular ELF backend linker to do all the work.  */
5358   if (! bfd_elf_final_link (abfd, info))
5359     return FALSE;
5360
5361   /* Now write out the computed sections.  */
5362
5363   /* The .got subsections...  */
5364   {
5365     bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5366     for (i = htab->got_list;
5367          i != NULL;
5368          i = alpha_elf_tdata(i)->got_link_next)
5369       {
5370         asection *sgot;
5371
5372         /* elf_bfd_final_link already did everything in dynobj.  */
5373         if (i == dynobj)
5374           continue;
5375
5376         sgot = alpha_elf_tdata(i)->got;
5377         if (! bfd_set_section_contents (abfd, sgot->output_section,
5378                                         sgot->contents,
5379                                         (file_ptr) sgot->output_offset,
5380                                         sgot->size))
5381           return FALSE;
5382       }
5383   }
5384
5385   if (mdebug_sec != (asection *) NULL)
5386     {
5387       BFD_ASSERT (abfd->output_has_begun);
5388       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5389                                                swap, info,
5390                                                mdebug_sec->filepos))
5391         return FALSE;
5392
5393       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5394     }
5395
5396   return TRUE;
5397 }
5398
5399 static enum elf_reloc_type_class
5400 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5401                               const asection *rel_sec ATTRIBUTE_UNUSED,
5402                               const Elf_Internal_Rela *rela)
5403 {
5404   switch ((int) ELF64_R_TYPE (rela->r_info))
5405     {
5406     case R_ALPHA_RELATIVE:
5407       return reloc_class_relative;
5408     case R_ALPHA_JMP_SLOT:
5409       return reloc_class_plt;
5410     case R_ALPHA_COPY:
5411       return reloc_class_copy;
5412     default:
5413       return reloc_class_normal;
5414     }
5415 }
5416 \f
5417 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5418 {
5419   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5420   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5421   { NULL,                     0,  0, 0,            0 }
5422 };
5423
5424 /* ECOFF swapping routines.  These are used when dealing with the
5425    .mdebug section, which is in the ECOFF debugging format.  Copied
5426    from elf32-mips.c.  */
5427 static const struct ecoff_debug_swap
5428 elf64_alpha_ecoff_debug_swap =
5429 {
5430   /* Symbol table magic number.  */
5431   magicSym2,
5432   /* Alignment of debugging information.  E.g., 4.  */
5433   8,
5434   /* Sizes of external symbolic information.  */
5435   sizeof (struct hdr_ext),
5436   sizeof (struct dnr_ext),
5437   sizeof (struct pdr_ext),
5438   sizeof (struct sym_ext),
5439   sizeof (struct opt_ext),
5440   sizeof (struct fdr_ext),
5441   sizeof (struct rfd_ext),
5442   sizeof (struct ext_ext),
5443   /* Functions to swap in external symbolic data.  */
5444   ecoff_swap_hdr_in,
5445   ecoff_swap_dnr_in,
5446   ecoff_swap_pdr_in,
5447   ecoff_swap_sym_in,
5448   ecoff_swap_opt_in,
5449   ecoff_swap_fdr_in,
5450   ecoff_swap_rfd_in,
5451   ecoff_swap_ext_in,
5452   _bfd_ecoff_swap_tir_in,
5453   _bfd_ecoff_swap_rndx_in,
5454   /* Functions to swap out external symbolic data.  */
5455   ecoff_swap_hdr_out,
5456   ecoff_swap_dnr_out,
5457   ecoff_swap_pdr_out,
5458   ecoff_swap_sym_out,
5459   ecoff_swap_opt_out,
5460   ecoff_swap_fdr_out,
5461   ecoff_swap_rfd_out,
5462   ecoff_swap_ext_out,
5463   _bfd_ecoff_swap_tir_out,
5464   _bfd_ecoff_swap_rndx_out,
5465   /* Function to read in symbolic data.  */
5466   elf64_alpha_read_ecoff_info
5467 };
5468 \f
5469 /* Use a non-standard hash bucket size of 8.  */
5470
5471 static const struct elf_size_info alpha_elf_size_info =
5472 {
5473   sizeof (Elf64_External_Ehdr),
5474   sizeof (Elf64_External_Phdr),
5475   sizeof (Elf64_External_Shdr),
5476   sizeof (Elf64_External_Rel),
5477   sizeof (Elf64_External_Rela),
5478   sizeof (Elf64_External_Sym),
5479   sizeof (Elf64_External_Dyn),
5480   sizeof (Elf_External_Note),
5481   8,
5482   1,
5483   64, 3,
5484   ELFCLASS64, EV_CURRENT,
5485   bfd_elf64_write_out_phdrs,
5486   bfd_elf64_write_shdrs_and_ehdr,
5487   bfd_elf64_checksum_contents,
5488   bfd_elf64_write_relocs,
5489   bfd_elf64_swap_symbol_in,
5490   bfd_elf64_swap_symbol_out,
5491   bfd_elf64_slurp_reloc_table,
5492   bfd_elf64_slurp_symbol_table,
5493   bfd_elf64_swap_dyn_in,
5494   bfd_elf64_swap_dyn_out,
5495   bfd_elf64_swap_reloc_in,
5496   bfd_elf64_swap_reloc_out,
5497   bfd_elf64_swap_reloca_in,
5498   bfd_elf64_swap_reloca_out
5499 };
5500
5501 #define TARGET_LITTLE_SYM       alpha_elf64_vec
5502 #define TARGET_LITTLE_NAME      "elf64-alpha"
5503 #define ELF_ARCH                bfd_arch_alpha
5504 #define ELF_TARGET_ID           ALPHA_ELF_DATA
5505 #define ELF_MACHINE_CODE        EM_ALPHA
5506 #define ELF_MAXPAGESIZE 0x10000
5507 #define ELF_COMMONPAGESIZE      0x2000
5508
5509 #define bfd_elf64_bfd_link_hash_table_create \
5510   elf64_alpha_bfd_link_hash_table_create
5511
5512 #define bfd_elf64_bfd_reloc_type_lookup \
5513   elf64_alpha_bfd_reloc_type_lookup
5514 #define bfd_elf64_bfd_reloc_name_lookup \
5515   elf64_alpha_bfd_reloc_name_lookup
5516 #define elf_info_to_howto \
5517   elf64_alpha_info_to_howto
5518
5519 #define bfd_elf64_mkobject \
5520   elf64_alpha_mkobject
5521 #define elf_backend_object_p \
5522   elf64_alpha_object_p
5523
5524 #define elf_backend_section_from_shdr \
5525   elf64_alpha_section_from_shdr
5526 #define elf_backend_section_flags \
5527   elf64_alpha_section_flags
5528 #define elf_backend_fake_sections \
5529   elf64_alpha_fake_sections
5530
5531 #define bfd_elf64_bfd_is_local_label_name \
5532   elf64_alpha_is_local_label_name
5533 #define bfd_elf64_find_nearest_line \
5534   elf64_alpha_find_nearest_line
5535 #define bfd_elf64_bfd_relax_section \
5536   elf64_alpha_relax_section
5537
5538 #define elf_backend_add_symbol_hook \
5539   elf64_alpha_add_symbol_hook
5540 #define elf_backend_relocs_compatible \
5541   _bfd_elf_relocs_compatible
5542 #define elf_backend_sort_relocs_p \
5543   elf64_alpha_sort_relocs_p
5544 #define elf_backend_check_relocs \
5545   elf64_alpha_check_relocs
5546 #define elf_backend_create_dynamic_sections \
5547   elf64_alpha_create_dynamic_sections
5548 #define elf_backend_adjust_dynamic_symbol \
5549   elf64_alpha_adjust_dynamic_symbol
5550 #define elf_backend_merge_symbol_attribute \
5551   elf64_alpha_merge_symbol_attribute
5552 #define elf_backend_copy_indirect_symbol \
5553   elf64_alpha_copy_indirect_symbol
5554 #define elf_backend_always_size_sections \
5555   elf64_alpha_always_size_sections
5556 #define elf_backend_size_dynamic_sections \
5557   elf64_alpha_size_dynamic_sections
5558 #define elf_backend_omit_section_dynsym \
5559   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5560 #define elf_backend_relocate_section \
5561   elf64_alpha_relocate_section
5562 #define elf_backend_finish_dynamic_symbol \
5563   elf64_alpha_finish_dynamic_symbol
5564 #define elf_backend_finish_dynamic_sections \
5565   elf64_alpha_finish_dynamic_sections
5566 #define bfd_elf64_bfd_final_link \
5567   elf64_alpha_final_link
5568 #define elf_backend_reloc_type_class \
5569   elf64_alpha_reloc_type_class
5570
5571 #define elf_backend_can_gc_sections     1
5572 #define elf_backend_gc_mark_hook        elf64_alpha_gc_mark_hook
5573 #define elf_backend_gc_sweep_hook       elf64_alpha_gc_sweep_hook
5574
5575 #define elf_backend_ecoff_debug_swap \
5576   &elf64_alpha_ecoff_debug_swap
5577
5578 #define elf_backend_size_info \
5579   alpha_elf_size_info
5580
5581 #define elf_backend_special_sections \
5582   elf64_alpha_special_sections
5583
5584 /* A few constants that determine how the .plt section is set up.  */
5585 #define elf_backend_want_got_plt 0
5586 #define elf_backend_plt_readonly 0
5587 #define elf_backend_want_plt_sym 1
5588 #define elf_backend_got_header_size 0
5589 #define elf_backend_dtrel_excludes_plt 1
5590
5591 #include "elf64-target.h"
5592 \f
5593 /* FreeBSD support.  */
5594
5595 #undef TARGET_LITTLE_SYM
5596 #define TARGET_LITTLE_SYM       alpha_elf64_fbsd_vec
5597 #undef TARGET_LITTLE_NAME
5598 #define TARGET_LITTLE_NAME      "elf64-alpha-freebsd"
5599 #undef  ELF_OSABI
5600 #define ELF_OSABI               ELFOSABI_FREEBSD
5601
5602 /* The kernel recognizes executables as valid only if they carry a
5603    "FreeBSD" label in the ELF header.  So we put this label on all
5604    executables and (for simplicity) also all other object files.  */
5605
5606 static void
5607 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5608         struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5609 {
5610   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
5611
5612   i_ehdrp = elf_elfheader (abfd);
5613
5614   /* Put an ABI label supported by FreeBSD >= 4.1.  */
5615   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5616 #ifdef OLD_FREEBSD_ABI_LABEL
5617   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5618   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5619 #endif
5620 }
5621
5622 #undef elf_backend_post_process_headers
5623 #define elf_backend_post_process_headers \
5624   elf64_alpha_fbsd_post_process_headers
5625
5626 #undef  elf64_bed
5627 #define elf64_bed elf64_alpha_fbsd_bed
5628
5629 #include "elf64-target.h"