Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / contrib / binutils / bfd / elf64-alpha.c
1 /* Alpha specific support for 64-bit ELF
2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3    Free Software Foundation, Inc.
4    Contributed by Richard Henderson <rth@tamu.edu>.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21
22 /* $FreeBSD: src/contrib/binutils/bfd/elf64-alpha.c,v 1.3.2.5 2002/09/01 23:43:38 obrien Exp $ */
23 /* $DragonFly: src/contrib/binutils/bfd/Attic/elf64-alpha.c,v 1.2 2003/06/17 04:23:58 dillon Exp $ */
24
25 /* We need a published ABI spec for this.  Until one comes out, don't
26    assume this'll remain unchanged forever.  */
27
28 #include "bfd.h"
29 #include "sysdep.h"
30 #include "libbfd.h"
31 #include "elf-bfd.h"
32
33 #include "elf/alpha.h"
34
35 #define ALPHAECOFF
36
37 #define NO_COFF_RELOCS
38 #define NO_COFF_SYMBOLS
39 #define NO_COFF_LINENOS
40
41 /* Get the ECOFF swapping routines.  Needed for the debug information.  */
42 #include "coff/internal.h"
43 #include "coff/sym.h"
44 #include "coff/symconst.h"
45 #include "coff/ecoff.h"
46 #include "coff/alpha.h"
47 #include "aout/ar.h"
48 #include "libcoff.h"
49 #include "libecoff.h"
50 #define ECOFF_64
51 #include "ecoffswap.h"
52
53 static int alpha_elf_dynamic_symbol_p
54   PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
55 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
56   PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
57 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
58   PARAMS((bfd *));
59
60 static bfd_reloc_status_type elf64_alpha_reloc_nil
61   PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
62 static bfd_reloc_status_type elf64_alpha_reloc_bad
63   PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
64 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
65   PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
66 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
67   PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
68
69 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
70   PARAMS((bfd *, bfd_reloc_code_real_type));
71 static void elf64_alpha_info_to_howto
72   PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
73
74 static boolean elf64_alpha_mkobject
75   PARAMS((bfd *));
76 static boolean elf64_alpha_object_p
77   PARAMS((bfd *));
78 static boolean elf64_alpha_section_from_shdr
79   PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
80 static boolean elf64_alpha_section_flags
81   PARAMS((flagword *, Elf64_Internal_Shdr *));
82 static boolean elf64_alpha_fake_sections
83   PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
84 static boolean elf64_alpha_create_got_section
85   PARAMS((bfd *, struct bfd_link_info *));
86 static boolean elf64_alpha_create_dynamic_sections
87   PARAMS((bfd *, struct bfd_link_info *));
88
89 static boolean elf64_alpha_read_ecoff_info
90   PARAMS((bfd *, asection *, struct ecoff_debug_info *));
91 static boolean elf64_alpha_is_local_label_name
92   PARAMS((bfd *, const char *));
93 static boolean elf64_alpha_find_nearest_line
94   PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
95           const char **, unsigned int *));
96
97 #if defined(__STDC__) || defined(ALMOST_STDC)
98 struct alpha_elf_link_hash_entry;
99 #endif
100
101 static boolean elf64_alpha_output_extsym
102   PARAMS((struct alpha_elf_link_hash_entry *, PTR));
103
104 static boolean elf64_alpha_can_merge_gots
105   PARAMS((bfd *, bfd *));
106 static void elf64_alpha_merge_gots
107   PARAMS((bfd *, bfd *));
108 static boolean elf64_alpha_calc_got_offsets_for_symbol
109   PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
110 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
111 static boolean elf64_alpha_size_got_sections
112   PARAMS ((bfd *, struct bfd_link_info *));
113 static boolean elf64_alpha_always_size_sections
114   PARAMS ((bfd *, struct bfd_link_info *));
115 static boolean elf64_alpha_calc_dynrel_sizes
116   PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
117 static boolean elf64_alpha_add_symbol_hook
118   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
119            const char **, flagword *, asection **, bfd_vma *));
120 static boolean elf64_alpha_check_relocs
121   PARAMS((bfd *, struct bfd_link_info *, asection *sec,
122           const Elf_Internal_Rela *));
123 static boolean elf64_alpha_adjust_dynamic_symbol
124   PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
125 static boolean elf64_alpha_size_dynamic_sections
126   PARAMS((bfd *, struct bfd_link_info *));
127 static boolean elf64_alpha_relocate_section
128   PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
129           Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
130 static boolean elf64_alpha_finish_dynamic_symbol
131   PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
132           Elf_Internal_Sym *));
133 static boolean elf64_alpha_finish_dynamic_sections
134   PARAMS((bfd *, struct bfd_link_info *));
135 static boolean elf64_alpha_final_link
136   PARAMS((bfd *, struct bfd_link_info *));
137 static boolean elf64_alpha_merge_ind_symbols
138   PARAMS((struct alpha_elf_link_hash_entry *, PTR));
139 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
140   PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
141 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
142   PARAMS ((const Elf_Internal_Rela *));
143 \f
144 struct alpha_elf_link_hash_entry
145 {
146   struct elf_link_hash_entry root;
147
148   /* External symbol information.  */
149   EXTR esym;
150
151   /* Cumulative flags for all the .got entries.  */
152   int flags;
153
154   /* Contexts (LITUSE) in which a literal was referenced.  */
155 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
156 #define ALPHA_ELF_LINK_HASH_LU_MEM  0x02
157 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
158 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
159
160   /* Used to implement multiple .got subsections.  */
161   struct alpha_elf_got_entry
162   {
163     struct alpha_elf_got_entry *next;
164
165     /* which .got subsection?  */
166     bfd *gotobj;
167
168     /* the addend in effect for this entry.  */
169     bfd_vma addend;
170
171     /* the .got offset for this entry.  */
172     int got_offset;
173
174     int flags;
175
176     /* Additional flags.  */
177 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
178 #define ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED 0x20
179
180     int use_count;
181   } *got_entries;
182
183   /* used to count non-got, non-plt relocations for delayed sizing
184      of relocation sections.  */
185   struct alpha_elf_reloc_entry
186   {
187     struct alpha_elf_reloc_entry *next;
188
189     /* which .reloc section? */
190     asection *srel;
191
192     /* what kind of relocation? */
193     unsigned int rtype;
194
195     /* is this against read-only section? */
196     unsigned int reltext : 1;
197
198     /* how many did we find?  */
199     unsigned long count;
200   } *reloc_entries;
201 };
202
203 /* Alpha ELF linker hash table.  */
204
205 struct alpha_elf_link_hash_table
206 {
207   struct elf_link_hash_table root;
208
209   /* The head of a list of .got subsections linked through
210      alpha_elf_tdata(abfd)->got_link_next.  */
211   bfd *got_list;
212 };
213
214 /* Look up an entry in a Alpha ELF linker hash table.  */
215
216 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
217   ((struct alpha_elf_link_hash_entry *)                                 \
218    elf_link_hash_lookup (&(table)->root, (string), (create),            \
219                          (copy), (follow)))
220
221 /* Traverse a Alpha ELF linker hash table.  */
222
223 #define alpha_elf_link_hash_traverse(table, func, info)                 \
224   (elf_link_hash_traverse                                               \
225    (&(table)->root,                                                     \
226     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
227     (info)))
228
229 /* Get the Alpha ELF linker hash table from a link_info structure.  */
230
231 #define alpha_elf_hash_table(p) \
232   ((struct alpha_elf_link_hash_table *) ((p)->hash))
233
234 /* Get the object's symbols as our own entry type.  */
235
236 #define alpha_elf_sym_hashes(abfd) \
237   ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
238
239 /* Should we do dynamic things to this symbol?  */
240
241 static int
242 alpha_elf_dynamic_symbol_p (h, info)
243      struct elf_link_hash_entry *h;
244      struct bfd_link_info *info;
245 {
246   if (h == NULL)
247     return false;
248
249   while (h->root.type == bfd_link_hash_indirect
250          || h->root.type == bfd_link_hash_warning)
251     h = (struct elf_link_hash_entry *) h->root.u.i.link;
252
253   if (h->dynindx == -1)
254     return false;
255
256   if (h->root.type == bfd_link_hash_undefweak
257       || h->root.type == bfd_link_hash_defweak)
258     return true;
259
260   switch (ELF_ST_VISIBILITY (h->other))
261     {
262     case STV_DEFAULT:
263       break;
264     case STV_HIDDEN:
265     case STV_INTERNAL:
266       return false;
267     case STV_PROTECTED:
268       if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
269         return false;
270       break;
271     }
272
273   if ((info->shared && !info->symbolic)
274       || ((h->elf_link_hash_flags
275            & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
276           == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
277     return true;
278
279   return false;
280 }
281
282 /* Create an entry in a Alpha ELF linker hash table.  */
283
284 static struct bfd_hash_entry *
285 elf64_alpha_link_hash_newfunc (entry, table, string)
286      struct bfd_hash_entry *entry;
287      struct bfd_hash_table *table;
288      const char *string;
289 {
290   struct alpha_elf_link_hash_entry *ret =
291     (struct alpha_elf_link_hash_entry *) entry;
292
293   /* Allocate the structure if it has not already been allocated by a
294      subclass.  */
295   if (ret == (struct alpha_elf_link_hash_entry *) NULL)
296     ret = ((struct alpha_elf_link_hash_entry *)
297            bfd_hash_allocate (table,
298                               sizeof (struct alpha_elf_link_hash_entry)));
299   if (ret == (struct alpha_elf_link_hash_entry *) NULL)
300     return (struct bfd_hash_entry *) ret;
301
302   /* Call the allocation method of the superclass.  */
303   ret = ((struct alpha_elf_link_hash_entry *)
304          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
305                                      table, string));
306   if (ret != (struct alpha_elf_link_hash_entry *) NULL)
307     {
308       /* Set local fields.  */
309       memset (&ret->esym, 0, sizeof (EXTR));
310       /* We use -2 as a marker to indicate that the information has
311          not been set.  -1 means there is no associated ifd.  */
312       ret->esym.ifd = -2;
313       ret->flags = 0;
314       ret->got_entries = NULL;
315       ret->reloc_entries = NULL;
316     }
317
318   return (struct bfd_hash_entry *) ret;
319 }
320
321 /* Create a Alpha ELF linker hash table.  */
322
323 static struct bfd_link_hash_table *
324 elf64_alpha_bfd_link_hash_table_create (abfd)
325      bfd *abfd;
326 {
327   struct alpha_elf_link_hash_table *ret;
328   bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
329
330   ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
331   if (ret == (struct alpha_elf_link_hash_table *) NULL)
332     return NULL;
333
334   if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
335                                        elf64_alpha_link_hash_newfunc))
336     {
337       bfd_release (abfd, ret);
338       return NULL;
339     }
340
341   return &ret->root.root;
342 }
343 \f
344 /* We have some private fields hanging off of the elf_tdata structure.  */
345
346 struct alpha_elf_obj_tdata
347 {
348   struct elf_obj_tdata root;
349
350   /* For every input file, these are the got entries for that object's
351      local symbols.  */
352   struct alpha_elf_got_entry ** local_got_entries;
353
354   /* For every input file, this is the object that owns the got that
355      this input file uses.  */
356   bfd *gotobj;
357
358   /* For every got, this is a linked list through the objects using this got */
359   bfd *in_got_link_next;
360
361   /* For every got, this is a link to the next got subsegment.  */
362   bfd *got_link_next;
363
364   /* For every got, this is the section.  */
365   asection *got;
366
367   /* For every got, this is it's total number of *entries*.  */
368   int total_got_entries;
369
370   /* For every got, this is the sum of the number of *entries* required
371      to hold all of the member object's local got.  */
372   int n_local_got_entries;
373 };
374
375 #define alpha_elf_tdata(abfd) \
376   ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
377
378 static boolean
379 elf64_alpha_mkobject (abfd)
380      bfd *abfd;
381 {
382   bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
383   abfd->tdata.any = bfd_zalloc (abfd, amt);
384   if (abfd->tdata.any == NULL)
385     return false;
386   return true;
387 }
388
389 static boolean
390 elf64_alpha_object_p (abfd)
391      bfd *abfd;
392 {
393   /* Allocate our special target data.  */
394   struct alpha_elf_obj_tdata *new_tdata;
395   bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
396   new_tdata = bfd_zalloc (abfd, amt);
397   if (new_tdata == NULL)
398     return false;
399   new_tdata->root = *abfd->tdata.elf_obj_data;
400   abfd->tdata.any = new_tdata;
401
402   /* Set the right machine number for an Alpha ELF file.  */
403   return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
404 }
405 \f
406 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
407    from smaller values.  Start with zero, widen, *then* decrement.  */
408 #define MINUS_ONE       (((bfd_vma)0) - 1)
409
410 #define SKIP_HOWTO(N) \
411   HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
412
413 static reloc_howto_type elf64_alpha_howto_table[] =
414 {
415   HOWTO (R_ALPHA_NONE,          /* type */
416          0,                     /* rightshift */
417          0,                     /* size (0 = byte, 1 = short, 2 = long) */
418          8,                     /* bitsize */
419          true,                  /* pc_relative */
420          0,                     /* bitpos */
421          complain_overflow_dont, /* complain_on_overflow */
422          elf64_alpha_reloc_nil, /* special_function */
423          "NONE",                /* name */
424          false,                 /* partial_inplace */
425          0,                     /* src_mask */
426          0,                     /* dst_mask */
427          true),                 /* pcrel_offset */
428
429   /* A 32 bit reference to a symbol.  */
430   HOWTO (R_ALPHA_REFLONG,       /* type */
431          0,                     /* rightshift */
432          2,                     /* size (0 = byte, 1 = short, 2 = long) */
433          32,                    /* bitsize */
434          false,                 /* pc_relative */
435          0,                     /* bitpos */
436          complain_overflow_bitfield, /* complain_on_overflow */
437          0,                     /* special_function */
438          "REFLONG",             /* name */
439          false,                 /* partial_inplace */
440          0xffffffff,            /* src_mask */
441          0xffffffff,            /* dst_mask */
442          false),                /* pcrel_offset */
443
444   /* A 64 bit reference to a symbol.  */
445   HOWTO (R_ALPHA_REFQUAD,       /* type */
446          0,                     /* rightshift */
447          4,                     /* size (0 = byte, 1 = short, 2 = long) */
448          64,                    /* bitsize */
449          false,                 /* pc_relative */
450          0,                     /* bitpos */
451          complain_overflow_bitfield, /* complain_on_overflow */
452          0,                     /* special_function */
453          "REFQUAD",             /* name */
454          false,                 /* partial_inplace */
455          MINUS_ONE,             /* src_mask */
456          MINUS_ONE,             /* dst_mask */
457          false),                /* pcrel_offset */
458
459   /* A 32 bit GP relative offset.  This is just like REFLONG except
460      that when the value is used the value of the gp register will be
461      added in.  */
462   HOWTO (R_ALPHA_GPREL32,       /* type */
463          0,                     /* rightshift */
464          2,                     /* size (0 = byte, 1 = short, 2 = long) */
465          32,                    /* bitsize */
466          false,                 /* pc_relative */
467          0,                     /* bitpos */
468          complain_overflow_bitfield, /* complain_on_overflow */
469          0,                     /* special_function */
470          "GPREL32",             /* name */
471          false,                 /* partial_inplace */
472          0xffffffff,            /* src_mask */
473          0xffffffff,            /* dst_mask */
474          false),                /* pcrel_offset */
475
476   /* Used for an instruction that refers to memory off the GP register.  */
477   HOWTO (R_ALPHA_LITERAL,       /* type */
478          0,                     /* rightshift */
479          1,                     /* size (0 = byte, 1 = short, 2 = long) */
480          16,                    /* bitsize */
481          false,                 /* pc_relative */
482          0,                     /* bitpos */
483          complain_overflow_signed, /* complain_on_overflow */
484          0,                     /* special_function */
485          "ELF_LITERAL",         /* name */
486          false,                 /* partial_inplace */
487          0xffff,                /* src_mask */
488          0xffff,                /* dst_mask */
489          false),                /* pcrel_offset */
490
491   /* This reloc only appears immediately following an ELF_LITERAL reloc.
492      It identifies a use of the literal.  The symbol index is special:
493      1 means the literal address is in the base register of a memory
494      format instruction; 2 means the literal address is in the byte
495      offset register of a byte-manipulation instruction; 3 means the
496      literal address is in the target register of a jsr instruction.
497      This does not actually do any relocation.  */
498   HOWTO (R_ALPHA_LITUSE,        /* type */
499          0,                     /* rightshift */
500          1,                     /* size (0 = byte, 1 = short, 2 = long) */
501          32,                    /* bitsize */
502          false,                 /* pc_relative */
503          0,                     /* bitpos */
504          complain_overflow_dont, /* complain_on_overflow */
505          elf64_alpha_reloc_nil, /* special_function */
506          "LITUSE",              /* name */
507          false,                 /* partial_inplace */
508          0,                     /* src_mask */
509          0,                     /* dst_mask */
510          false),                /* pcrel_offset */
511
512   /* Load the gp register.  This is always used for a ldah instruction
513      which loads the upper 16 bits of the gp register.  The symbol
514      index of the GPDISP instruction is an offset in bytes to the lda
515      instruction that loads the lower 16 bits.  The value to use for
516      the relocation is the difference between the GP value and the
517      current location; the load will always be done against a register
518      holding the current address.
519
520      NOTE: Unlike ECOFF, partial in-place relocation is not done.  If
521      any offset is present in the instructions, it is an offset from
522      the register to the ldah instruction.  This lets us avoid any
523      stupid hackery like inventing a gp value to do partial relocation
524      against.  Also unlike ECOFF, we do the whole relocation off of
525      the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair.  An odd,
526      space consuming bit, that, since all the information was present
527      in the GPDISP_HI16 reloc.  */
528   HOWTO (R_ALPHA_GPDISP,        /* type */
529          16,                    /* rightshift */
530          2,                     /* size (0 = byte, 1 = short, 2 = long) */
531          16,                    /* bitsize */
532          false,                 /* pc_relative */
533          0,                     /* bitpos */
534          complain_overflow_dont, /* complain_on_overflow */
535          elf64_alpha_reloc_gpdisp, /* special_function */
536          "GPDISP",              /* name */
537          false,                 /* partial_inplace */
538          0xffff,                /* src_mask */
539          0xffff,                /* dst_mask */
540          true),                 /* pcrel_offset */
541
542   /* A 21 bit branch.  */
543   HOWTO (R_ALPHA_BRADDR,        /* type */
544          2,                     /* rightshift */
545          2,                     /* size (0 = byte, 1 = short, 2 = long) */
546          21,                    /* bitsize */
547          true,                  /* pc_relative */
548          0,                     /* bitpos */
549          complain_overflow_signed, /* complain_on_overflow */
550          0,                     /* special_function */
551          "BRADDR",              /* name */
552          false,                 /* partial_inplace */
553          0x1fffff,              /* src_mask */
554          0x1fffff,              /* dst_mask */
555          true),                 /* pcrel_offset */
556
557   /* A hint for a jump to a register.  */
558   HOWTO (R_ALPHA_HINT,          /* type */
559          2,                     /* rightshift */
560          1,                     /* size (0 = byte, 1 = short, 2 = long) */
561          14,                    /* bitsize */
562          true,                  /* pc_relative */
563          0,                     /* bitpos */
564          complain_overflow_dont, /* complain_on_overflow */
565          0,                     /* special_function */
566          "HINT",                /* name */
567          false,                 /* partial_inplace */
568          0x3fff,                /* src_mask */
569          0x3fff,                /* dst_mask */
570          true),                 /* pcrel_offset */
571
572   /* 16 bit PC relative offset.  */
573   HOWTO (R_ALPHA_SREL16,        /* type */
574          0,                     /* rightshift */
575          1,                     /* size (0 = byte, 1 = short, 2 = long) */
576          16,                    /* bitsize */
577          true,                  /* pc_relative */
578          0,                     /* bitpos */
579          complain_overflow_signed, /* complain_on_overflow */
580          0,                     /* special_function */
581          "SREL16",              /* name */
582          false,                 /* partial_inplace */
583          0xffff,                /* src_mask */
584          0xffff,                /* dst_mask */
585          true),                 /* pcrel_offset */
586
587   /* 32 bit PC relative offset.  */
588   HOWTO (R_ALPHA_SREL32,        /* type */
589          0,                     /* rightshift */
590          2,                     /* size (0 = byte, 1 = short, 2 = long) */
591          32,                    /* bitsize */
592          true,                  /* pc_relative */
593          0,                     /* bitpos */
594          complain_overflow_signed, /* complain_on_overflow */
595          0,                     /* special_function */
596          "SREL32",              /* name */
597          false,                 /* partial_inplace */
598          0xffffffff,            /* src_mask */
599          0xffffffff,            /* dst_mask */
600          true),                 /* pcrel_offset */
601
602   /* A 64 bit PC relative offset.  */
603   HOWTO (R_ALPHA_SREL64,        /* type */
604          0,                     /* rightshift */
605          4,                     /* size (0 = byte, 1 = short, 2 = long) */
606          64,                    /* bitsize */
607          true,                  /* pc_relative */
608          0,                     /* bitpos */
609          complain_overflow_signed, /* complain_on_overflow */
610          0,                     /* special_function */
611          "SREL64",              /* name */
612          false,                 /* partial_inplace */
613          MINUS_ONE,             /* src_mask */
614          MINUS_ONE,             /* dst_mask */
615          true),                 /* pcrel_offset */
616
617   /* Skip 12 - 16; deprecated ECOFF relocs.  */
618   SKIP_HOWTO (12),
619   SKIP_HOWTO (13),
620   SKIP_HOWTO (14),
621   SKIP_HOWTO (15),
622   SKIP_HOWTO (16),
623
624   /* The high 16 bits of the displacement from GP to the target.  */
625   HOWTO (R_ALPHA_GPRELHIGH,
626          0,                     /* rightshift */
627          1,                     /* size (0 = byte, 1 = short, 2 = long) */
628          16,                    /* bitsize */
629          false,                 /* pc_relative */
630          0,                     /* bitpos */
631          complain_overflow_signed, /* complain_on_overflow */
632          0,                     /* special_function */
633          "GPRELHIGH",           /* name */
634          false,                 /* partial_inplace */
635          0xffff,                /* src_mask */
636          0xffff,                /* dst_mask */
637          false),                /* pcrel_offset */
638
639   /* The low 16 bits of the displacement from GP to the target.  */
640   HOWTO (R_ALPHA_GPRELLOW,
641          0,                     /* rightshift */
642          1,                     /* size (0 = byte, 1 = short, 2 = long) */
643          16,                    /* bitsize */
644          false,                 /* pc_relative */
645          0,                     /* bitpos */
646          complain_overflow_dont, /* complain_on_overflow */
647          0,                     /* special_function */
648          "GPRELLOW",            /* name */
649          false,                 /* partial_inplace */
650          0xffff,                /* src_mask */
651          0xffff,                /* dst_mask */
652          false),                /* pcrel_offset */
653
654   /* A 16-bit displacement from the GP to the target.  */
655   HOWTO (R_ALPHA_GPREL16,
656          0,                     /* rightshift */
657          1,                     /* size (0 = byte, 1 = short, 2 = long) */
658          16,                    /* bitsize */
659          false,                 /* pc_relative */
660          0,                     /* bitpos */
661          complain_overflow_signed, /* complain_on_overflow */
662          0,                     /* special_function */
663          "GPREL16",             /* name */
664          false,                 /* partial_inplace */
665          0xffff,                /* src_mask */
666          0xffff,                /* dst_mask */
667          false),                /* pcrel_offset */
668
669   /* Skip 20 - 23; deprecated ECOFF relocs.  */
670   SKIP_HOWTO (20),
671   SKIP_HOWTO (21),
672   SKIP_HOWTO (22),
673   SKIP_HOWTO (23),
674
675   /* Misc ELF relocations.  */
676
677   /* A dynamic relocation to copy the target into our .dynbss section.  */
678   /* Not generated, as all Alpha objects use PIC, so it is not needed.  It
679      is present because every other ELF has one, but should not be used
680      because .dynbss is an ugly thing.  */
681   HOWTO (R_ALPHA_COPY,
682          0,
683          0,
684          0,
685          false,
686          0,
687          complain_overflow_dont,
688          bfd_elf_generic_reloc,
689          "COPY",
690          false,
691          0,
692          0,
693          true),
694
695   /* A dynamic relocation for a .got entry.  */
696   HOWTO (R_ALPHA_GLOB_DAT,
697          0,
698          0,
699          0,
700          false,
701          0,
702          complain_overflow_dont,
703          bfd_elf_generic_reloc,
704          "GLOB_DAT",
705          false,
706          0,
707          0,
708          true),
709
710   /* A dynamic relocation for a .plt entry.  */
711   HOWTO (R_ALPHA_JMP_SLOT,
712          0,
713          0,
714          0,
715          false,
716          0,
717          complain_overflow_dont,
718          bfd_elf_generic_reloc,
719          "JMP_SLOT",
720          false,
721          0,
722          0,
723          true),
724
725   /* A dynamic relocation to add the base of the DSO to a 64-bit field.  */
726   HOWTO (R_ALPHA_RELATIVE,
727          0,
728          0,
729          0,
730          false,
731          0,
732          complain_overflow_dont,
733          bfd_elf_generic_reloc,
734          "RELATIVE",
735          false,
736          0,
737          0,
738          true),
739
740   /* A 21 bit branch that adjusts for gp loads.  */
741   HOWTO (R_ALPHA_BRSGP,         /* type */
742          2,                     /* rightshift */
743          2,                     /* size (0 = byte, 1 = short, 2 = long) */
744          21,                    /* bitsize */
745          true,                  /* pc_relative */
746          0,                     /* bitpos */
747          complain_overflow_signed, /* complain_on_overflow */
748          0,                     /* special_function */
749          "BRSGP",               /* name */
750          false,                 /* partial_inplace */
751          0x1fffff,              /* src_mask */
752          0x1fffff,              /* dst_mask */
753          true),                 /* pcrel_offset */
754 };
755
756 /* A relocation function which doesn't do anything.  */
757
758 static bfd_reloc_status_type
759 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
760      bfd *abfd ATTRIBUTE_UNUSED;
761      arelent *reloc;
762      asymbol *sym ATTRIBUTE_UNUSED;
763      PTR data ATTRIBUTE_UNUSED;
764      asection *sec;
765      bfd *output_bfd;
766      char **error_message ATTRIBUTE_UNUSED;
767 {
768   if (output_bfd)
769     reloc->address += sec->output_offset;
770   return bfd_reloc_ok;
771 }
772
773 /* A relocation function used for an unsupported reloc.  */
774
775 static bfd_reloc_status_type
776 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
777      bfd *abfd ATTRIBUTE_UNUSED;
778      arelent *reloc;
779      asymbol *sym ATTRIBUTE_UNUSED;
780      PTR data ATTRIBUTE_UNUSED;
781      asection *sec;
782      bfd *output_bfd;
783      char **error_message ATTRIBUTE_UNUSED;
784 {
785   if (output_bfd)
786     reloc->address += sec->output_offset;
787   return bfd_reloc_notsupported;
788 }
789
790 /* Do the work of the GPDISP relocation.  */
791
792 static bfd_reloc_status_type
793 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
794      bfd *abfd;
795      bfd_vma gpdisp;
796      bfd_byte *p_ldah;
797      bfd_byte *p_lda;
798 {
799   bfd_reloc_status_type ret = bfd_reloc_ok;
800   bfd_vma addend;
801   unsigned long i_ldah, i_lda;
802
803   i_ldah = bfd_get_32 (abfd, p_ldah);
804   i_lda = bfd_get_32 (abfd, p_lda);
805
806   /* Complain if the instructions are not correct.  */
807   if (((i_ldah >> 26) & 0x3f) != 0x09
808       || ((i_lda >> 26) & 0x3f) != 0x08)
809     ret = bfd_reloc_dangerous;
810
811   /* Extract the user-supplied offset, mirroring the sign extensions
812      that the instructions perform.  */
813   addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
814   addend = (addend ^ 0x80008000) - 0x80008000;
815
816   gpdisp += addend;
817
818   if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
819       || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
820     ret = bfd_reloc_overflow;
821
822   /* compensate for the sign extension again.  */
823   i_ldah = ((i_ldah & 0xffff0000)
824             | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
825   i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
826
827   bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
828   bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
829
830   return ret;
831 }
832
833 /* The special function for the GPDISP reloc.  */
834
835 static bfd_reloc_status_type
836 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
837                           output_bfd, err_msg)
838      bfd *abfd;
839      arelent *reloc_entry;
840      asymbol *sym ATTRIBUTE_UNUSED;
841      PTR data;
842      asection *input_section;
843      bfd *output_bfd;
844      char **err_msg;
845 {
846   bfd_reloc_status_type ret;
847   bfd_vma gp, relocation;
848   bfd_byte *p_ldah, *p_lda;
849
850   /* Don't do anything if we're not doing a final link.  */
851   if (output_bfd)
852     {
853       reloc_entry->address += input_section->output_offset;
854       return bfd_reloc_ok;
855     }
856
857   if (reloc_entry->address > input_section->_cooked_size ||
858       reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
859     return bfd_reloc_outofrange;
860
861   /* The gp used in the portion of the output object to which this
862      input object belongs is cached on the input bfd.  */
863   gp = _bfd_get_gp_value (abfd);
864
865   relocation = (input_section->output_section->vma
866                 + input_section->output_offset
867                 + reloc_entry->address);
868
869   p_ldah = (bfd_byte *) data + reloc_entry->address;
870   p_lda = p_ldah + reloc_entry->addend;
871
872   ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
873
874   /* Complain if the instructions are not correct.  */
875   if (ret == bfd_reloc_dangerous)
876     *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
877
878   return ret;
879 }
880
881 /* A mapping from BFD reloc types to Alpha ELF reloc types.  */
882
883 struct elf_reloc_map
884 {
885   bfd_reloc_code_real_type bfd_reloc_val;
886   int elf_reloc_val;
887 };
888
889 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
890 {
891   {BFD_RELOC_NONE,                      R_ALPHA_NONE},
892   {BFD_RELOC_32,                        R_ALPHA_REFLONG},
893   {BFD_RELOC_64,                        R_ALPHA_REFQUAD},
894   {BFD_RELOC_CTOR,                      R_ALPHA_REFQUAD},
895   {BFD_RELOC_GPREL32,                   R_ALPHA_GPREL32},
896   {BFD_RELOC_ALPHA_ELF_LITERAL,         R_ALPHA_LITERAL},
897   {BFD_RELOC_ALPHA_LITUSE,              R_ALPHA_LITUSE},
898   {BFD_RELOC_ALPHA_GPDISP,              R_ALPHA_GPDISP},
899   {BFD_RELOC_23_PCREL_S2,               R_ALPHA_BRADDR},
900   {BFD_RELOC_ALPHA_HINT,                R_ALPHA_HINT},
901   {BFD_RELOC_16_PCREL,                  R_ALPHA_SREL16},
902   {BFD_RELOC_32_PCREL,                  R_ALPHA_SREL32},
903   {BFD_RELOC_64_PCREL,                  R_ALPHA_SREL64},
904   {BFD_RELOC_ALPHA_GPREL_HI16,          R_ALPHA_GPRELHIGH},
905   {BFD_RELOC_ALPHA_GPREL_LO16,          R_ALPHA_GPRELLOW},
906   {BFD_RELOC_GPREL16,                   R_ALPHA_GPREL16},
907   {BFD_RELOC_ALPHA_BRSGP,               R_ALPHA_BRSGP},
908 };
909
910 /* Given a BFD reloc type, return a HOWTO structure.  */
911
912 static reloc_howto_type *
913 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
914      bfd *abfd ATTRIBUTE_UNUSED;
915      bfd_reloc_code_real_type code;
916 {
917   const struct elf_reloc_map *i, *e;
918   i = e = elf64_alpha_reloc_map;
919   e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
920   for (; i != e; ++i)
921     {
922       if (i->bfd_reloc_val == code)
923         return &elf64_alpha_howto_table[i->elf_reloc_val];
924     }
925   return 0;
926 }
927
928 /* Given an Alpha ELF reloc type, fill in an arelent structure.  */
929
930 static void
931 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
932      bfd *abfd ATTRIBUTE_UNUSED;
933      arelent *cache_ptr;
934      Elf64_Internal_Rela *dst;
935 {
936   unsigned r_type;
937
938   r_type = ELF64_R_TYPE(dst->r_info);
939   BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
940   cache_ptr->howto = &elf64_alpha_howto_table[r_type];
941 }
942 \f
943 /* These functions do relaxation for Alpha ELF.
944
945    Currently I'm only handling what I can do with existing compiler
946    and assembler support, which means no instructions are removed,
947    though some may be nopped.  At this time GCC does not emit enough
948    information to do all of the relaxing that is possible.  It will
949    take some not small amount of work for that to happen.
950
951    There are a couple of interesting papers that I once read on this
952    subject, that I cannot find references to at the moment, that
953    related to Alpha in particular.  They are by David Wall, then of
954    DEC WRL.  */
955
956 #define OP_LDA          0x08
957 #define OP_LDAH         0x09
958 #define INSN_JSR        0x68004000
959 #define INSN_JSR_MASK   0xfc00c000
960 #define OP_LDQ          0x29
961 #define OP_BR           0x30
962 #define OP_BSR          0x34
963 #define INSN_UNOP       0x2ffe0000
964
965 struct alpha_relax_info
966 {
967   bfd *abfd;
968   asection *sec;
969   bfd_byte *contents;
970   Elf_Internal_Rela *relocs, *relend;
971   struct bfd_link_info *link_info;
972   boolean changed_contents;
973   boolean changed_relocs;
974   bfd_vma gp;
975   bfd *gotobj;
976   asection *tsec;
977   struct alpha_elf_link_hash_entry *h;
978   struct alpha_elf_got_entry *gotent;
979   unsigned char other;
980 };
981
982 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
983   PARAMS((struct alpha_relax_info *info, bfd_vma symval,
984           Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
985
986 static boolean elf64_alpha_relax_without_lituse
987   PARAMS((struct alpha_relax_info *info, bfd_vma symval,
988           Elf_Internal_Rela *irel));
989
990 static bfd_vma elf64_alpha_relax_opt_call
991   PARAMS((struct alpha_relax_info *info, bfd_vma symval));
992
993 static boolean elf64_alpha_relax_section
994   PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
995           boolean *again));
996
997 static Elf_Internal_Rela *
998 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
999      Elf_Internal_Rela *rel, *relend;
1000      bfd_vma offset;
1001      int type;
1002 {
1003   while (rel < relend)
1004     {
1005       if (rel->r_offset == offset
1006           && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
1007         return rel;
1008       ++rel;
1009     }
1010   return NULL;
1011 }
1012
1013 static Elf_Internal_Rela *
1014 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1015      struct alpha_relax_info *info;
1016      bfd_vma symval;
1017      Elf_Internal_Rela *irel, *irelend;
1018 {
1019   Elf_Internal_Rela *urel;
1020   int flags, count, i;
1021   bfd_signed_vma disp;
1022   boolean fits16;
1023   boolean fits32;
1024   boolean lit_reused = false;
1025   boolean all_optimized = true;
1026   unsigned int lit_insn;
1027
1028   lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1029   if (lit_insn >> 26 != OP_LDQ)
1030     {
1031       ((*_bfd_error_handler)
1032        ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1033         bfd_archive_filename (info->abfd), info->sec->name,
1034         (unsigned long) irel->r_offset));
1035       return irel;
1036     }
1037
1038   /* Summarize how this particular LITERAL is used.  */
1039   for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1040     {
1041       if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1042         break;
1043       if (urel->r_addend <= 3)
1044         flags |= 1 << urel->r_addend;
1045     }
1046
1047   /* A little preparation for the loop...  */
1048   disp = symval - info->gp;
1049
1050   for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1051     {
1052       unsigned int insn;
1053       int insn_disp;
1054       bfd_signed_vma xdisp;
1055
1056       insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1057
1058       switch (urel->r_addend)
1059         {
1060         default: /* 0 = ADDRESS FORMAT */
1061           /* This type is really just a placeholder to note that all
1062              uses cannot be optimized, but to still allow some.  */
1063           all_optimized = false;
1064           break;
1065
1066         case 1: /* MEM FORMAT */
1067           /* We can always optimize 16-bit displacements.  */
1068
1069           /* Extract the displacement from the instruction, sign-extending
1070              it if necessary, then test whether it is within 16 or 32 bits
1071              displacement from GP.  */
1072           insn_disp = insn & 0x0000ffff;
1073           if (insn_disp & 0x00008000)
1074             insn_disp |= 0xffff0000;  /* Negative: sign-extend.  */
1075
1076           xdisp = disp + insn_disp;
1077           fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1078           fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1079
1080           if (fits16)
1081             {
1082               /* Take the op code and dest from this insn, take the base
1083                  register from the literal insn.  Leave the offset alone.  */
1084               insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1085               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1086                                            R_ALPHA_GPREL16);
1087               urel->r_addend = irel->r_addend;
1088               info->changed_relocs = true;
1089
1090               bfd_put_32 (info->abfd, (bfd_vma) insn,
1091                           info->contents + urel->r_offset);
1092               info->changed_contents = true;
1093             }
1094
1095           /* If all mem+byte, we can optimize 32-bit mem displacements.  */
1096           else if (fits32 && !(flags & ~6))
1097             {
1098               /* FIXME: sanity check that lit insn Ra is mem insn Rb.  */
1099
1100               irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1101                                            R_ALPHA_GPRELHIGH);
1102               lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1103               bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1104                           info->contents + irel->r_offset);
1105               lit_reused = true;
1106               info->changed_contents = true;
1107
1108               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1109                                            R_ALPHA_GPRELLOW);
1110               urel->r_addend = irel->r_addend;
1111               info->changed_relocs = true;
1112             }
1113           else
1114             all_optimized = false;
1115           break;
1116
1117         case 2: /* BYTE OFFSET FORMAT */
1118           /* We can always optimize byte instructions.  */
1119
1120           /* FIXME: sanity check the insn for byte op.  Check that the
1121              literal dest reg is indeed Rb in the byte insn.  */
1122
1123           insn &= ~ (unsigned) 0x001ff000;
1124           insn |= ((symval & 7) << 13) | 0x1000;
1125
1126           urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1127           urel->r_addend = 0;
1128           info->changed_relocs = true;
1129
1130           bfd_put_32 (info->abfd, (bfd_vma) insn,
1131                       info->contents + urel->r_offset);
1132           info->changed_contents = true;
1133           break;
1134
1135         case 3: /* CALL FORMAT */
1136           {
1137             /* If not zero, place to jump without needing pv.  */
1138             bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1139             bfd_vma org = (info->sec->output_section->vma
1140                            + info->sec->output_offset
1141                            + urel->r_offset + 4);
1142             bfd_signed_vma odisp;
1143
1144             odisp = (optdest ? optdest : symval) - org;
1145             if (odisp >= -0x400000 && odisp < 0x400000)
1146               {
1147                 Elf_Internal_Rela *xrel;
1148
1149                 /* Preserve branch prediction call stack when possible.  */
1150                 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1151                   insn = (OP_BSR << 26) | (insn & 0x03e00000);
1152                 else
1153                   insn = (OP_BR << 26) | (insn & 0x03e00000);
1154
1155                 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1156                                              R_ALPHA_BRADDR);
1157                 urel->r_addend = irel->r_addend;
1158
1159                 if (optdest)
1160                   urel->r_addend += optdest - symval;
1161                 else
1162                   all_optimized = false;
1163
1164                 bfd_put_32 (info->abfd, (bfd_vma) insn,
1165                             info->contents + urel->r_offset);
1166
1167                 /* Kill any HINT reloc that might exist for this insn.  */
1168                 xrel = (elf64_alpha_find_reloc_at_ofs
1169                         (info->relocs, info->relend, urel->r_offset,
1170                          R_ALPHA_HINT));
1171                 if (xrel)
1172                   xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1173
1174                 info->changed_contents = true;
1175                 info->changed_relocs = true;
1176               }
1177             else
1178               all_optimized = false;
1179
1180             /* Even if the target is not in range for a direct branch,
1181                if we share a GP, we can eliminate the gp reload.  */
1182             if (optdest)
1183               {
1184                 Elf_Internal_Rela *gpdisp
1185                   = (elf64_alpha_find_reloc_at_ofs
1186                      (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1187                 if (gpdisp)
1188                   {
1189                     bfd_byte *p_ldah = info->contents + gpdisp->r_offset; 
1190                     bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1191                     unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1192                     unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1193
1194                     /* Verify that the instruction is "ldah $29,0($26)".
1195                        Consider a function that ends in a noreturn call,
1196                        and that the next function begins with an ldgp,
1197                        and that by accident there is no padding between.
1198                        In that case the insn would use $27 as the base.  */
1199                     if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1200                       {
1201                         bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1202                         bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1203
1204                         gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1205                         info->changed_contents = true;
1206                         info->changed_relocs = true;
1207                       }
1208                   }
1209               }
1210           }
1211           break;
1212         }
1213     }
1214
1215   /* If all cases were optimized, we can reduce the use count on this
1216      got entry by one, possibly eliminating it.  */
1217   if (all_optimized)
1218     {
1219       info->gotent->use_count -= 1;
1220       alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1221       if (!info->h)
1222         alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1223
1224       /* If the literal instruction is no longer needed (it may have been
1225          reused.  We can eliminate it.
1226          ??? For now, I don't want to deal with compacting the section,
1227          so just nop it out.  */
1228       if (!lit_reused)
1229         {
1230           irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1231           info->changed_relocs = true;
1232
1233           bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1234                       info->contents + irel->r_offset);
1235           info->changed_contents = true;
1236         }
1237     }
1238
1239   return irel + count;
1240 }
1241
1242 static bfd_vma
1243 elf64_alpha_relax_opt_call (info, symval)
1244      struct alpha_relax_info *info;
1245      bfd_vma symval;
1246 {
1247   /* If the function has the same gp, and we can identify that the
1248      function does not use its function pointer, we can eliminate the
1249      address load.  */
1250
1251   /* If the symbol is marked NOPV, we are being told the function never
1252      needs its procedure value.  */
1253   if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1254     return symval;
1255
1256   /* If the symbol is marked STD_GP, we are being told the function does
1257      a normal ldgp in the first two words.  */
1258   else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1259     ;
1260
1261   /* Otherwise, we may be able to identify a GP load in the first two
1262      words, which we can then skip.  */
1263   else
1264     {
1265       Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1266       bfd_vma ofs;
1267
1268       /* Load the relocations from the section that the target symbol is in.  */
1269       if (info->sec == info->tsec)
1270         {
1271           tsec_relocs = info->relocs;
1272           tsec_relend = info->relend;
1273           tsec_free = NULL;
1274         }
1275       else
1276         {
1277           tsec_relocs = (_bfd_elf64_link_read_relocs
1278                          (info->abfd, info->tsec, (PTR) NULL,
1279                          (Elf_Internal_Rela *) NULL,
1280                          info->link_info->keep_memory));
1281           if (tsec_relocs == NULL)
1282             return 0;
1283           tsec_relend = tsec_relocs + info->tsec->reloc_count;
1284           tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1285         }
1286
1287       /* Recover the symbol's offset within the section.  */
1288       ofs = (symval - info->tsec->output_section->vma
1289              - info->tsec->output_offset);
1290
1291       /* Look for a GPDISP reloc.  */
1292       gpdisp = (elf64_alpha_find_reloc_at_ofs
1293                 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1294
1295       if (!gpdisp || gpdisp->r_addend != 4)
1296         {
1297           if (tsec_free)
1298             free (tsec_free);
1299           return 0;
1300         }
1301       if (tsec_free)
1302         free (tsec_free);
1303     }
1304
1305   /* We've now determined that we can skip an initial gp load.  Verify
1306      that the call and the target use the same gp.   */
1307   if (info->link_info->hash->creator != info->tsec->owner->xvec
1308       || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1309     return 0;
1310
1311   return symval + 8;
1312 }
1313
1314 static boolean
1315 elf64_alpha_relax_without_lituse (info, symval, irel)
1316      struct alpha_relax_info *info;
1317      bfd_vma symval;
1318      Elf_Internal_Rela *irel;
1319 {
1320   unsigned int insn;
1321   bfd_signed_vma disp;
1322
1323   /* Get the instruction.  */
1324   insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1325
1326   if (insn >> 26 != OP_LDQ)
1327     {
1328       ((*_bfd_error_handler)
1329        ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1330         bfd_archive_filename (info->abfd), info->sec->name,
1331         (unsigned long) irel->r_offset));
1332       return true;
1333     }
1334
1335   /* So we aren't told much.  Do what we can with the address load and
1336      fake the rest.  All of the optimizations here require that the
1337      offset from the GP fit in 16 bits.  */
1338
1339   disp = symval - info->gp;
1340   if (disp < -0x8000 || disp >= 0x8000)
1341     return true;
1342
1343   /* On the LITERAL instruction itself, consider exchanging
1344      `ldq R,X(gp)' for `lda R,Y(gp)'.  */
1345
1346   insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1347   bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1348   info->changed_contents = true;
1349
1350   irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1351   info->changed_relocs = true;
1352
1353   /* Reduce the use count on this got entry by one, possibly
1354      eliminating it.  */
1355   info->gotent->use_count -= 1;
1356   alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1357   if (!info->h)
1358     alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1359
1360   /* ??? Search forward through this basic block looking for insns
1361      that use the target register.  Stop after an insn modifying the
1362      register is seen, or after a branch or call.
1363
1364      Any such memory load insn may be substituted by a load directly
1365      off the GP.  This allows the memory load insn to be issued before
1366      the calculated GP register would otherwise be ready.
1367
1368      Any such jsr insn can be replaced by a bsr if it is in range.
1369
1370      This would mean that we'd have to _add_ relocations, the pain of
1371      which gives one pause.  */
1372
1373   return true;
1374 }
1375
1376 static boolean
1377 elf64_alpha_relax_section (abfd, sec, link_info, again)
1378      bfd *abfd;
1379      asection *sec;
1380      struct bfd_link_info *link_info;
1381      boolean *again;
1382 {
1383   Elf_Internal_Shdr *symtab_hdr;
1384   Elf_Internal_Shdr *shndx_hdr;
1385   Elf_Internal_Rela *internal_relocs;
1386   Elf_Internal_Rela *free_relocs = NULL;
1387   Elf_Internal_Rela *irel, *irelend;
1388   bfd_byte *free_contents = NULL;
1389   Elf64_External_Sym *extsyms = NULL;
1390   Elf64_External_Sym *free_extsyms = NULL;
1391   Elf_External_Sym_Shndx *shndx_buf = NULL;
1392   struct alpha_elf_got_entry **local_got_entries;
1393   struct alpha_relax_info info;
1394
1395   /* We are not currently changing any sizes, so only one pass.  */
1396   *again = false;
1397
1398   if (link_info->relocateable
1399       || (sec->flags & SEC_RELOC) == 0
1400       || sec->reloc_count == 0)
1401     return true;
1402
1403   /* If this is the first time we have been called for this section,
1404      initialize the cooked size.  */
1405   if (sec->_cooked_size == 0)
1406     sec->_cooked_size = sec->_raw_size;
1407
1408   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1409   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1410
1411   /* Load the relocations for this section.  */
1412   internal_relocs = (_bfd_elf64_link_read_relocs
1413                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1414                       link_info->keep_memory));
1415   if (internal_relocs == NULL)
1416     goto error_return;
1417   if (! link_info->keep_memory)
1418     free_relocs = internal_relocs;
1419
1420   memset(&info, 0, sizeof (info));
1421   info.abfd = abfd;
1422   info.sec = sec;
1423   info.link_info = link_info;
1424   info.relocs = internal_relocs;
1425   info.relend = irelend = internal_relocs + sec->reloc_count;
1426
1427   /* Find the GP for this object.  */
1428   info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1429   if (info.gotobj)
1430     {
1431       asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1432       info.gp = _bfd_get_gp_value (info.gotobj);
1433       if (info.gp == 0)
1434         {
1435           info.gp = (sgot->output_section->vma
1436                      + sgot->output_offset
1437                      + 0x8000);
1438           _bfd_set_gp_value (info.gotobj, info.gp);
1439         }
1440     }
1441
1442   for (irel = internal_relocs; irel < irelend; irel++)
1443     {
1444       bfd_vma symval;
1445       Elf_Internal_Sym isym;
1446       struct alpha_elf_got_entry *gotent;
1447
1448       if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1449         continue;
1450
1451       /* Get the section contents.  */
1452       if (info.contents == NULL)
1453         {
1454           if (elf_section_data (sec)->this_hdr.contents != NULL)
1455             info.contents = elf_section_data (sec)->this_hdr.contents;
1456           else
1457             {
1458               info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1459               if (info.contents == NULL)
1460                 goto error_return;
1461               free_contents = info.contents;
1462
1463               if (! bfd_get_section_contents (abfd, sec, info.contents,
1464                                               (file_ptr) 0, sec->_raw_size))
1465                 goto error_return;
1466             }
1467         }
1468
1469       /* Read this BFD's symbols if we haven't done so already.  */
1470       if (extsyms == NULL)
1471         {
1472           bfd_size_type amt;
1473
1474           if (symtab_hdr->contents != NULL)
1475             extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1476           else
1477             {
1478               amt = symtab_hdr->sh_info;
1479               amt *= sizeof (Elf64_External_Sym);
1480               extsyms = (Elf64_External_Sym *) bfd_malloc (amt);
1481               if (extsyms == NULL)
1482                 goto error_return;
1483               free_extsyms = extsyms;
1484               if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1485                   || bfd_bread ((PTR) extsyms, amt, abfd) != amt)
1486                 goto error_return;
1487             }
1488
1489           shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1490           if (shndx_hdr->sh_size != 0)
1491             {
1492               amt = symtab_hdr->sh_info;
1493               amt *= sizeof (Elf_External_Sym_Shndx);
1494               shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1495               if (shndx_buf == NULL)
1496                 goto error_return;
1497               if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1498                   || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1499                 goto error_return;
1500             }
1501         }
1502
1503       /* Get the value of the symbol referred to by the reloc.  */
1504       if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1505         {
1506           /* A local symbol.  */
1507           Elf64_External_Sym *esym;
1508           Elf_External_Sym_Shndx *shndx;
1509
1510           esym = extsyms + ELF64_R_SYM (irel->r_info);
1511           shndx = shndx_buf + (shndx_buf ? ELF64_R_SYM (irel->r_info) : 0);
1512           bfd_elf64_swap_symbol_in (abfd, esym, shndx, &isym);
1513           if (isym.st_shndx == SHN_UNDEF)
1514             info.tsec = bfd_und_section_ptr;
1515           else if (isym.st_shndx == SHN_ABS)
1516             info.tsec = bfd_abs_section_ptr;
1517           else if (isym.st_shndx == SHN_COMMON)
1518             info.tsec = bfd_com_section_ptr;
1519           else
1520             info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1521
1522           info.h = NULL;
1523           info.other = isym.st_other;
1524           gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1525           symval = isym.st_value;
1526         }
1527       else
1528         {
1529           unsigned long indx;
1530           struct alpha_elf_link_hash_entry *h;
1531
1532           indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1533           h = alpha_elf_sym_hashes (abfd)[indx];
1534           BFD_ASSERT (h != NULL);
1535
1536           while (h->root.root.type == bfd_link_hash_indirect
1537                  || h->root.root.type == bfd_link_hash_warning)
1538             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1539
1540           /* We can't do anthing with undefined or dynamic symbols.  */
1541           if (h->root.root.type == bfd_link_hash_undefined
1542               || h->root.root.type == bfd_link_hash_undefweak
1543               || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1544             continue;
1545
1546           info.h = h;
1547           info.tsec = h->root.root.u.def.section;
1548           info.other = h->root.other;
1549           gotent = h->got_entries;
1550           symval = h->root.root.u.def.value;
1551         }
1552
1553       /* Search for the got entry to be used by this relocation.  */
1554       while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1555         gotent = gotent->next;
1556       info.gotent = gotent;
1557
1558       symval += info.tsec->output_section->vma + info.tsec->output_offset;
1559       symval += irel->r_addend;
1560
1561       BFD_ASSERT(info.gotent != NULL);
1562
1563       /* If there exist LITUSE relocations immediately following, this
1564          opens up all sorts of interesting optimizations, because we
1565          now know every location that this address load is used.  */
1566
1567       if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1568         {
1569           irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1570           if (irel == NULL)
1571             goto error_return;
1572         }
1573       else
1574         {
1575           if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1576             goto error_return;
1577         }
1578     }
1579
1580   if (!elf64_alpha_size_got_sections (abfd, link_info))
1581     return false;
1582
1583   if (info.changed_relocs)
1584     {
1585       elf_section_data (sec)->relocs = internal_relocs;
1586     }
1587   else if (free_relocs != NULL)
1588     {
1589       free (free_relocs);
1590     }
1591
1592   if (info.changed_contents)
1593     {
1594       elf_section_data (sec)->this_hdr.contents = info.contents;
1595     }
1596   else if (free_contents != NULL)
1597     {
1598       if (! link_info->keep_memory)
1599         free (free_contents);
1600       else
1601         {
1602           /* Cache the section contents for elf_link_input_bfd.  */
1603           elf_section_data (sec)->this_hdr.contents = info.contents;
1604         }
1605     }
1606
1607   if (shndx_buf != NULL)
1608     free (shndx_buf);
1609
1610   if (free_extsyms != NULL)
1611     {
1612       if (! link_info->keep_memory)
1613         free (free_extsyms);
1614       else
1615         {
1616           /* Cache the symbols for elf_link_input_bfd.  */
1617           symtab_hdr->contents = (unsigned char *) extsyms;
1618         }
1619     }
1620
1621   *again = info.changed_contents || info.changed_relocs;
1622
1623   return true;
1624
1625  error_return:
1626   if (free_relocs != NULL)
1627     free (free_relocs);
1628   if (free_contents != NULL)
1629     free (free_contents);
1630   if (shndx_buf != NULL)
1631     free (shndx_buf);
1632   if (free_extsyms != NULL)
1633     free (free_extsyms);
1634   return false;
1635 }
1636 \f
1637 /* PLT/GOT Stuff */
1638 #define PLT_HEADER_SIZE 32
1639 #define PLT_HEADER_WORD1        (bfd_vma) 0xc3600000    /* br   $27,.+4     */
1640 #define PLT_HEADER_WORD2        (bfd_vma) 0xa77b000c    /* ldq  $27,12($27) */
1641 #define PLT_HEADER_WORD3        (bfd_vma) 0x47ff041f    /* nop              */
1642 #define PLT_HEADER_WORD4        (bfd_vma) 0x6b7b0000    /* jmp  $27,($27)   */
1643
1644 #define PLT_ENTRY_SIZE 12
1645 #define PLT_ENTRY_WORD1         0xc3800000      /* br   $28, plt0   */
1646 #define PLT_ENTRY_WORD2         0
1647 #define PLT_ENTRY_WORD3         0
1648
1649 #define MAX_GOT_ENTRIES         (64*1024 / 8)
1650
1651 #ifndef ELF_DYNAMIC_INTERPRETER
1652 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1653 #endif
1654 \f
1655 /* Handle an Alpha specific section when reading an object file.  This
1656    is called when elfcode.h finds a section with an unknown type.
1657    FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1658    how to.  */
1659
1660 static boolean
1661 elf64_alpha_section_from_shdr (abfd, hdr, name)
1662      bfd *abfd;
1663      Elf64_Internal_Shdr *hdr;
1664      char *name;
1665 {
1666   asection *newsect;
1667
1668   /* There ought to be a place to keep ELF backend specific flags, but
1669      at the moment there isn't one.  We just keep track of the
1670      sections by their name, instead.  Fortunately, the ABI gives
1671      suggested names for all the MIPS specific sections, so we will
1672      probably get away with this.  */
1673   switch (hdr->sh_type)
1674     {
1675     case SHT_ALPHA_DEBUG:
1676       if (strcmp (name, ".mdebug") != 0)
1677         return false;
1678       break;
1679     default:
1680       return false;
1681     }
1682
1683   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1684     return false;
1685   newsect = hdr->bfd_section;
1686
1687   if (hdr->sh_type == SHT_ALPHA_DEBUG)
1688     {
1689       if (! bfd_set_section_flags (abfd, newsect,
1690                                    (bfd_get_section_flags (abfd, newsect)
1691                                     | SEC_DEBUGGING)))
1692         return false;
1693     }
1694
1695   return true;
1696 }
1697
1698 /* Convert Alpha specific section flags to bfd internal section flags.  */
1699
1700 static boolean
1701 elf64_alpha_section_flags (flags, hdr)
1702      flagword *flags;
1703      Elf64_Internal_Shdr *hdr;
1704 {
1705   if (hdr->sh_flags & SHF_ALPHA_GPREL)
1706     *flags |= SEC_SMALL_DATA;
1707
1708   return true;
1709 }
1710
1711 /* Set the correct type for an Alpha ELF section.  We do this by the
1712    section name, which is a hack, but ought to work.  */
1713
1714 static boolean
1715 elf64_alpha_fake_sections (abfd, hdr, sec)
1716      bfd *abfd;
1717      Elf64_Internal_Shdr *hdr;
1718      asection *sec;
1719 {
1720   register const char *name;
1721
1722   name = bfd_get_section_name (abfd, sec);
1723
1724   if (strcmp (name, ".mdebug") == 0)
1725     {
1726       hdr->sh_type = SHT_ALPHA_DEBUG;
1727       /* In a shared object on Irix 5.3, the .mdebug section has an
1728          entsize of 0.  FIXME: Does this matter?  */
1729       if ((abfd->flags & DYNAMIC) != 0 )
1730         hdr->sh_entsize = 0;
1731       else
1732         hdr->sh_entsize = 1;
1733     }
1734   else if ((sec->flags & SEC_SMALL_DATA)
1735            || strcmp (name, ".sdata") == 0
1736            || strcmp (name, ".sbss") == 0
1737            || strcmp (name, ".lit4") == 0
1738            || strcmp (name, ".lit8") == 0)
1739     hdr->sh_flags |= SHF_ALPHA_GPREL;
1740
1741   return true;
1742 }
1743
1744 /* Hook called by the linker routine which adds symbols from an object
1745    file.  We use it to put .comm items in .sbss, and not .bss.  */
1746
1747 static boolean
1748 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1749      bfd *abfd;
1750      struct bfd_link_info *info;
1751      const Elf_Internal_Sym *sym;
1752      const char **namep ATTRIBUTE_UNUSED;
1753      flagword *flagsp ATTRIBUTE_UNUSED;
1754      asection **secp;
1755      bfd_vma *valp;
1756 {
1757   if (sym->st_shndx == SHN_COMMON
1758       && !info->relocateable
1759       && sym->st_size <= elf_gp_size (abfd))
1760     {
1761       /* Common symbols less than or equal to -G nn bytes are
1762          automatically put into .sbss.  */
1763
1764       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1765
1766       if (scomm == NULL)
1767         {
1768           scomm = bfd_make_section (abfd, ".scommon");
1769           if (scomm == NULL
1770               || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1771                                                        | SEC_IS_COMMON
1772                                                        | SEC_LINKER_CREATED)))
1773             return false;
1774         }
1775
1776       *secp = scomm;
1777       *valp = sym->st_size;
1778     }
1779
1780   return true;
1781 }
1782
1783 /* Create the .got section.  */
1784
1785 static boolean
1786 elf64_alpha_create_got_section(abfd, info)
1787      bfd *abfd;
1788      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1789 {
1790   asection *s;
1791
1792   if (bfd_get_section_by_name (abfd, ".got"))
1793     return true;
1794
1795   s = bfd_make_section (abfd, ".got");
1796   if (s == NULL
1797       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1798                                            | SEC_HAS_CONTENTS
1799                                            | SEC_IN_MEMORY
1800                                            | SEC_LINKER_CREATED))
1801       || !bfd_set_section_alignment (abfd, s, 3))
1802     return false;
1803
1804   alpha_elf_tdata (abfd)->got = s;
1805
1806   return true;
1807 }
1808
1809 /* Create all the dynamic sections.  */
1810
1811 static boolean
1812 elf64_alpha_create_dynamic_sections (abfd, info)
1813      bfd *abfd;
1814      struct bfd_link_info *info;
1815 {
1816   asection *s;
1817   struct elf_link_hash_entry *h;
1818
1819   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
1820
1821   s = bfd_make_section (abfd, ".plt");
1822   if (s == NULL
1823       || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1824                                             | SEC_HAS_CONTENTS
1825                                             | SEC_IN_MEMORY
1826                                             | SEC_LINKER_CREATED
1827                                             | SEC_CODE))
1828       || ! bfd_set_section_alignment (abfd, s, 3))
1829     return false;
1830
1831   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1832      .plt section.  */
1833   h = NULL;
1834   if (! (_bfd_generic_link_add_one_symbol
1835          (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1836           (bfd_vma) 0, (const char *) NULL, false,
1837           get_elf_backend_data (abfd)->collect,
1838           (struct bfd_link_hash_entry **) &h)))
1839     return false;
1840   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1841   h->type = STT_OBJECT;
1842
1843   if (info->shared
1844       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1845     return false;
1846
1847   s = bfd_make_section (abfd, ".rela.plt");
1848   if (s == NULL
1849       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1850                                            | SEC_HAS_CONTENTS
1851                                            | SEC_IN_MEMORY
1852                                            | SEC_LINKER_CREATED
1853                                            | SEC_READONLY))
1854       || ! bfd_set_section_alignment (abfd, s, 3))
1855     return false;
1856
1857   /* We may or may not have created a .got section for this object, but
1858      we definitely havn't done the rest of the work.  */
1859
1860   if (!elf64_alpha_create_got_section (abfd, info))
1861     return false;
1862
1863   s = bfd_make_section(abfd, ".rela.got");
1864   if (s == NULL
1865       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1866                                            | SEC_HAS_CONTENTS
1867                                            | SEC_IN_MEMORY
1868                                            | SEC_LINKER_CREATED
1869                                            | SEC_READONLY))
1870       || !bfd_set_section_alignment (abfd, s, 3))
1871     return false;
1872
1873   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1874      dynobj's .got section.  We don't do this in the linker script
1875      because we don't want to define the symbol if we are not creating
1876      a global offset table.  */
1877   h = NULL;
1878   if (!(_bfd_generic_link_add_one_symbol
1879         (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1880          alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1881          false, get_elf_backend_data (abfd)->collect,
1882          (struct bfd_link_hash_entry **) &h)))
1883     return false;
1884   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1885   h->type = STT_OBJECT;
1886
1887   if (info->shared
1888       && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1889     return false;
1890
1891   elf_hash_table (info)->hgot = h;
1892
1893   return true;
1894 }
1895 \f
1896 /* Read ECOFF debugging information from a .mdebug section into a
1897    ecoff_debug_info structure.  */
1898
1899 static boolean
1900 elf64_alpha_read_ecoff_info (abfd, section, debug)
1901      bfd *abfd;
1902      asection *section;
1903      struct ecoff_debug_info *debug;
1904 {
1905   HDRR *symhdr;
1906   const struct ecoff_debug_swap *swap;
1907   char *ext_hdr = NULL;
1908
1909   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1910   memset (debug, 0, sizeof (*debug));
1911
1912   ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1913   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1914     goto error_return;
1915
1916   if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1917                                 swap->external_hdr_size)
1918       == false)
1919     goto error_return;
1920
1921   symhdr = &debug->symbolic_header;
1922   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1923
1924   /* The symbolic header contains absolute file offsets and sizes to
1925      read.  */
1926 #define READ(ptr, offset, count, size, type)                            \
1927   if (symhdr->count == 0)                                               \
1928     debug->ptr = NULL;                                                  \
1929   else                                                                  \
1930     {                                                                   \
1931       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1932       debug->ptr = (type) bfd_malloc (amt);                             \
1933       if (debug->ptr == NULL)                                           \
1934         goto error_return;                                              \
1935       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
1936           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1937         goto error_return;                                              \
1938     }
1939
1940   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1941   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1942   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1943   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1944   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1945   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1946         union aux_ext *);
1947   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1948   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1949   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1950   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1951   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1952 #undef READ
1953
1954   debug->fdr = NULL;
1955   debug->adjust = NULL;
1956
1957   return true;
1958
1959  error_return:
1960   if (ext_hdr != NULL)
1961     free (ext_hdr);
1962   if (debug->line != NULL)
1963     free (debug->line);
1964   if (debug->external_dnr != NULL)
1965     free (debug->external_dnr);
1966   if (debug->external_pdr != NULL)
1967     free (debug->external_pdr);
1968   if (debug->external_sym != NULL)
1969     free (debug->external_sym);
1970   if (debug->external_opt != NULL)
1971     free (debug->external_opt);
1972   if (debug->external_aux != NULL)
1973     free (debug->external_aux);
1974   if (debug->ss != NULL)
1975     free (debug->ss);
1976   if (debug->ssext != NULL)
1977     free (debug->ssext);
1978   if (debug->external_fdr != NULL)
1979     free (debug->external_fdr);
1980   if (debug->external_rfd != NULL)
1981     free (debug->external_rfd);
1982   if (debug->external_ext != NULL)
1983     free (debug->external_ext);
1984   return false;
1985 }
1986
1987 /* Alpha ELF local labels start with '$'.  */
1988
1989 static boolean
1990 elf64_alpha_is_local_label_name (abfd, name)
1991      bfd *abfd ATTRIBUTE_UNUSED;
1992      const char *name;
1993 {
1994   return name[0] == '$';
1995 }
1996
1997 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1998    routine in order to handle the ECOFF debugging information.  We
1999    still call this mips_elf_find_line because of the slot
2000    find_line_info in elf_obj_tdata is declared that way.  */
2001
2002 struct mips_elf_find_line
2003 {
2004   struct ecoff_debug_info d;
2005   struct ecoff_find_line i;
2006 };
2007
2008 static boolean
2009 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2010                                functionname_ptr, line_ptr)
2011      bfd *abfd;
2012      asection *section;
2013      asymbol **symbols;
2014      bfd_vma offset;
2015      const char **filename_ptr;
2016      const char **functionname_ptr;
2017      unsigned int *line_ptr;
2018 {
2019   asection *msec;
2020
2021   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2022                                      filename_ptr, functionname_ptr,
2023                                      line_ptr, 0,
2024                                      &elf_tdata (abfd)->dwarf2_find_line_info))
2025     return true;
2026
2027   msec = bfd_get_section_by_name (abfd, ".mdebug");
2028   if (msec != NULL)
2029     {
2030       flagword origflags;
2031       struct mips_elf_find_line *fi;
2032       const struct ecoff_debug_swap * const swap =
2033         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2034
2035       /* If we are called during a link, alpha_elf_final_link may have
2036          cleared the SEC_HAS_CONTENTS field.  We force it back on here
2037          if appropriate (which it normally will be).  */
2038       origflags = msec->flags;
2039       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2040         msec->flags |= SEC_HAS_CONTENTS;
2041
2042       fi = elf_tdata (abfd)->find_line_info;
2043       if (fi == NULL)
2044         {
2045           bfd_size_type external_fdr_size;
2046           char *fraw_src;
2047           char *fraw_end;
2048           struct fdr *fdr_ptr;
2049           bfd_size_type amt = sizeof (struct mips_elf_find_line);
2050
2051           fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2052           if (fi == NULL)
2053             {
2054               msec->flags = origflags;
2055               return false;
2056             }
2057
2058           if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2059             {
2060               msec->flags = origflags;
2061               return false;
2062             }
2063
2064           /* Swap in the FDR information.  */
2065           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2066           fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2067           if (fi->d.fdr == NULL)
2068             {
2069               msec->flags = origflags;
2070               return false;
2071             }
2072           external_fdr_size = swap->external_fdr_size;
2073           fdr_ptr = fi->d.fdr;
2074           fraw_src = (char *) fi->d.external_fdr;
2075           fraw_end = (fraw_src
2076                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
2077           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2078             (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2079
2080           elf_tdata (abfd)->find_line_info = fi;
2081
2082           /* Note that we don't bother to ever free this information.
2083              find_nearest_line is either called all the time, as in
2084              objdump -l, so the information should be saved, or it is
2085              rarely called, as in ld error messages, so the memory
2086              wasted is unimportant.  Still, it would probably be a
2087              good idea for free_cached_info to throw it away.  */
2088         }
2089
2090       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2091                                   &fi->i, filename_ptr, functionname_ptr,
2092                                   line_ptr))
2093         {
2094           msec->flags = origflags;
2095           return true;
2096         }
2097
2098       msec->flags = origflags;
2099     }
2100
2101   /* Fall back on the generic ELF find_nearest_line routine.  */
2102
2103   return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2104                                      filename_ptr, functionname_ptr,
2105                                      line_ptr);
2106 }
2107 \f
2108 /* Structure used to pass information to alpha_elf_output_extsym.  */
2109
2110 struct extsym_info
2111 {
2112   bfd *abfd;
2113   struct bfd_link_info *info;
2114   struct ecoff_debug_info *debug;
2115   const struct ecoff_debug_swap *swap;
2116   boolean failed;
2117 };
2118
2119 static boolean
2120 elf64_alpha_output_extsym (h, data)
2121      struct alpha_elf_link_hash_entry *h;
2122      PTR data;
2123 {
2124   struct extsym_info *einfo = (struct extsym_info *) data;
2125   boolean strip;
2126   asection *sec, *output_section;
2127
2128   if (h->root.root.type == bfd_link_hash_warning)
2129     h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2130
2131   if (h->root.indx == -2)
2132     strip = false;
2133   else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2134             || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2135            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2136            && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2137     strip = true;
2138   else if (einfo->info->strip == strip_all
2139            || (einfo->info->strip == strip_some
2140                && bfd_hash_lookup (einfo->info->keep_hash,
2141                                    h->root.root.root.string,
2142                                    false, false) == NULL))
2143     strip = true;
2144   else
2145     strip = false;
2146
2147   if (strip)
2148     return true;
2149
2150   if (h->esym.ifd == -2)
2151     {
2152       h->esym.jmptbl = 0;
2153       h->esym.cobol_main = 0;
2154       h->esym.weakext = 0;
2155       h->esym.reserved = 0;
2156       h->esym.ifd = ifdNil;
2157       h->esym.asym.value = 0;
2158       h->esym.asym.st = stGlobal;
2159
2160       if (h->root.root.type != bfd_link_hash_defined
2161           && h->root.root.type != bfd_link_hash_defweak)
2162         h->esym.asym.sc = scAbs;
2163       else
2164         {
2165           const char *name;
2166
2167           sec = h->root.root.u.def.section;
2168           output_section = sec->output_section;
2169
2170           /* When making a shared library and symbol h is the one from
2171              the another shared library, OUTPUT_SECTION may be null.  */
2172           if (output_section == NULL)
2173             h->esym.asym.sc = scUndefined;
2174           else
2175             {
2176               name = bfd_section_name (output_section->owner, output_section);
2177
2178               if (strcmp (name, ".text") == 0)
2179                 h->esym.asym.sc = scText;
2180               else if (strcmp (name, ".data") == 0)
2181                 h->esym.asym.sc = scData;
2182               else if (strcmp (name, ".sdata") == 0)
2183                 h->esym.asym.sc = scSData;
2184               else if (strcmp (name, ".rodata") == 0
2185                        || strcmp (name, ".rdata") == 0)
2186                 h->esym.asym.sc = scRData;
2187               else if (strcmp (name, ".bss") == 0)
2188                 h->esym.asym.sc = scBss;
2189               else if (strcmp (name, ".sbss") == 0)
2190                 h->esym.asym.sc = scSBss;
2191               else if (strcmp (name, ".init") == 0)
2192                 h->esym.asym.sc = scInit;
2193               else if (strcmp (name, ".fini") == 0)
2194                 h->esym.asym.sc = scFini;
2195               else
2196                 h->esym.asym.sc = scAbs;
2197             }
2198         }
2199
2200       h->esym.asym.reserved = 0;
2201       h->esym.asym.index = indexNil;
2202     }
2203
2204   if (h->root.root.type == bfd_link_hash_common)
2205     h->esym.asym.value = h->root.root.u.c.size;
2206   else if (h->root.root.type == bfd_link_hash_defined
2207            || h->root.root.type == bfd_link_hash_defweak)
2208     {
2209       if (h->esym.asym.sc == scCommon)
2210         h->esym.asym.sc = scBss;
2211       else if (h->esym.asym.sc == scSCommon)
2212         h->esym.asym.sc = scSBss;
2213
2214       sec = h->root.root.u.def.section;
2215       output_section = sec->output_section;
2216       if (output_section != NULL)
2217         h->esym.asym.value = (h->root.root.u.def.value
2218                               + sec->output_offset
2219                               + output_section->vma);
2220       else
2221         h->esym.asym.value = 0;
2222     }
2223   else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2224     {
2225       /* Set type and value for a symbol with a function stub.  */
2226       h->esym.asym.st = stProc;
2227       sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2228       if (sec == NULL)
2229         h->esym.asym.value = 0;
2230       else
2231         {
2232           output_section = sec->output_section;
2233           if (output_section != NULL)
2234             h->esym.asym.value = (h->root.plt.offset
2235                                   + sec->output_offset
2236                                   + output_section->vma);
2237           else
2238             h->esym.asym.value = 0;
2239         }
2240     }
2241
2242   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2243                                       h->root.root.root.string,
2244                                       &h->esym))
2245     {
2246       einfo->failed = true;
2247       return false;
2248     }
2249
2250   return true;
2251 }
2252
2253 /* FIXME:  Create a runtime procedure table from the .mdebug section.
2254
2255 static boolean
2256 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2257      PTR handle;
2258      bfd *abfd;
2259      struct bfd_link_info *info;
2260      asection *s;
2261      struct ecoff_debug_info *debug;
2262 */
2263 \f
2264 /* Handle dynamic relocations when doing an Alpha ELF link.  */
2265
2266 static boolean
2267 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2268      bfd *abfd;
2269      struct bfd_link_info *info;
2270      asection *sec;
2271      const Elf_Internal_Rela *relocs;
2272 {
2273   bfd *dynobj;
2274   asection *sreloc;
2275   const char *rel_sec_name;
2276   Elf_Internal_Shdr *symtab_hdr;
2277   struct alpha_elf_link_hash_entry **sym_hashes;
2278   struct alpha_elf_got_entry **local_got_entries;
2279   const Elf_Internal_Rela *rel, *relend;
2280   int got_created;
2281   bfd_size_type amt;
2282
2283   if (info->relocateable)
2284     return true;
2285
2286   dynobj = elf_hash_table(info)->dynobj;
2287   if (dynobj == NULL)
2288     elf_hash_table(info)->dynobj = dynobj = abfd;
2289
2290   sreloc = NULL;
2291   rel_sec_name = NULL;
2292   symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2293   sym_hashes = alpha_elf_sym_hashes(abfd);
2294   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2295   got_created = 0;
2296
2297   relend = relocs + sec->reloc_count;
2298   for (rel = relocs; rel < relend; ++rel)
2299     {
2300       unsigned long r_symndx, r_type;
2301       struct alpha_elf_link_hash_entry *h;
2302
2303       r_symndx = ELF64_R_SYM (rel->r_info);
2304       if (r_symndx < symtab_hdr->sh_info)
2305         h = NULL;
2306       else
2307         {
2308           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2309
2310           while (h->root.root.type == bfd_link_hash_indirect
2311                  || h->root.root.type == bfd_link_hash_warning)
2312             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2313
2314           h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2315         }
2316       r_type = ELF64_R_TYPE (rel->r_info);
2317
2318       switch (r_type)
2319         {
2320         case R_ALPHA_LITERAL:
2321           {
2322             struct alpha_elf_got_entry *gotent;
2323             int flags = 0;
2324
2325             if (h)
2326               {
2327                 /* Search for and possibly create a got entry.  */
2328                 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2329                   if (gotent->gotobj == abfd &&
2330                       gotent->addend == rel->r_addend)
2331                     break;
2332
2333                 if (!gotent)
2334                   {
2335                     amt = sizeof (struct alpha_elf_got_entry);
2336                     gotent = ((struct alpha_elf_got_entry *)
2337                               bfd_alloc (abfd, amt));
2338                     if (!gotent)
2339                       return false;
2340
2341                     gotent->gotobj = abfd;
2342                     gotent->addend = rel->r_addend;
2343                     gotent->got_offset = -1;
2344                     gotent->flags = 0;
2345                     gotent->use_count = 1;
2346
2347                     gotent->next = h->got_entries;
2348                     h->got_entries = gotent;
2349
2350                     alpha_elf_tdata (abfd)->total_got_entries++;
2351                   }
2352                 else
2353                   gotent->use_count += 1;
2354               }
2355             else
2356               {
2357                 /* This is a local .got entry -- record for merge.  */
2358                 if (!local_got_entries)
2359                   {
2360                     bfd_size_type size;
2361                     size = symtab_hdr->sh_info;
2362                     size *= sizeof (struct alpha_elf_got_entry *);
2363
2364                     local_got_entries = ((struct alpha_elf_got_entry **)
2365                                          bfd_alloc (abfd, size));
2366                     if (!local_got_entries)
2367                       return false;
2368
2369                     memset (local_got_entries, 0, (size_t) size);
2370                     alpha_elf_tdata (abfd)->local_got_entries =
2371                       local_got_entries;
2372                   }
2373
2374                 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2375                      gotent != NULL && gotent->addend != rel->r_addend;
2376                      gotent = gotent->next)
2377                   continue;
2378                 if (!gotent)
2379                   {
2380                     amt = sizeof (struct alpha_elf_got_entry);
2381                     gotent = ((struct alpha_elf_got_entry *)
2382                               bfd_alloc (abfd, amt));
2383                     if (!gotent)
2384                       return false;
2385
2386                     gotent->gotobj = abfd;
2387                     gotent->addend = rel->r_addend;
2388                     gotent->got_offset = -1;
2389                     gotent->flags = 0;
2390                     gotent->use_count = 1;
2391
2392                     gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2393                     local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2394
2395                     alpha_elf_tdata(abfd)->total_got_entries++;
2396                     alpha_elf_tdata(abfd)->n_local_got_entries++;
2397                   }
2398                 else
2399                   gotent->use_count += 1;
2400               }
2401
2402             /* Remember how this literal is used from its LITUSEs.
2403                This will be important when it comes to decide if we can
2404                create a .plt entry for a function symbol.  */
2405             if (rel+1 < relend
2406                 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2407               {
2408                 do
2409                   {
2410                     ++rel;
2411                     if (rel->r_addend >= 1 && rel->r_addend <= 3)
2412                       flags |= 1 << rel->r_addend;
2413                   }
2414                 while (rel+1 < relend &&
2415                        ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2416               }
2417             else
2418               {
2419                 /* No LITUSEs -- presumably the address is not being
2420                    loaded for nothing.  */
2421                 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2422               }
2423
2424             gotent->flags |= flags;
2425             if (h)
2426               {
2427                 /* Make a guess as to whether a .plt entry will be needed.  */
2428                 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2429                   h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2430                 else
2431                   h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2432               }
2433           }
2434           /* FALLTHRU */
2435
2436         case R_ALPHA_GPDISP:
2437         case R_ALPHA_GPREL16:
2438         case R_ALPHA_GPREL32:
2439         case R_ALPHA_GPRELHIGH:
2440         case R_ALPHA_GPRELLOW:
2441         case R_ALPHA_BRSGP:
2442           /* We don't actually use the .got here, but the sections must
2443              be created before the linker maps input sections to output
2444              sections.  */
2445           if (!got_created)
2446             {
2447               if (!elf64_alpha_create_got_section (abfd, info))
2448                 return false;
2449
2450               /* Make sure the object's gotobj is set to itself so
2451                  that we default to every object with its own .got.
2452                  We'll merge .gots later once we've collected each
2453                  object's info.  */
2454               alpha_elf_tdata(abfd)->gotobj = abfd;
2455
2456               got_created = 1;
2457             }
2458           break;
2459
2460         case R_ALPHA_SREL16:
2461         case R_ALPHA_SREL32:
2462         case R_ALPHA_SREL64:
2463           if (h == NULL)
2464             break;
2465           /* FALLTHRU */
2466
2467         case R_ALPHA_REFLONG:
2468         case R_ALPHA_REFQUAD:
2469           if (rel_sec_name == NULL)
2470             {
2471               rel_sec_name = (bfd_elf_string_from_elf_section
2472                               (abfd, elf_elfheader(abfd)->e_shstrndx,
2473                                elf_section_data(sec)->rel_hdr.sh_name));
2474               if (rel_sec_name == NULL)
2475                 return false;
2476
2477               BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2478                           && strcmp (bfd_get_section_name (abfd, sec),
2479                                      rel_sec_name+5) == 0);
2480             }
2481
2482           /* We need to create the section here now whether we eventually
2483              use it or not so that it gets mapped to an output section by
2484              the linker.  If not used, we'll kill it in
2485              size_dynamic_sections.  */
2486           if (sreloc == NULL)
2487             {
2488               sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2489               if (sreloc == NULL)
2490                 {
2491                   flagword flags;
2492
2493                   sreloc = bfd_make_section (dynobj, rel_sec_name);
2494                   flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2495                            | SEC_LINKER_CREATED | SEC_READONLY);
2496                   if (sec->flags & SEC_ALLOC)
2497                     flags |= SEC_ALLOC | SEC_LOAD;
2498                   if (sreloc == NULL
2499                       || !bfd_set_section_flags (dynobj, sreloc, flags)
2500                       || !bfd_set_section_alignment (dynobj, sreloc, 3))
2501                     return false;
2502                 }
2503             }
2504
2505           if (h)
2506             {
2507               /* Since we havn't seen all of the input symbols yet, we
2508                  don't know whether we'll actually need a dynamic relocation
2509                  entry for this reloc.  So make a record of it.  Once we
2510                  find out if this thing needs dynamic relocation we'll
2511                  expand the relocation sections by the appropriate amount.  */
2512
2513               struct alpha_elf_reloc_entry *rent;
2514
2515               for (rent = h->reloc_entries; rent; rent = rent->next)
2516                 if (rent->rtype == r_type && rent->srel == sreloc)
2517                   break;
2518
2519               if (!rent)
2520                 {
2521                   amt = sizeof (struct alpha_elf_reloc_entry);
2522                   rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
2523                   if (!rent)
2524                     return false;
2525
2526                   rent->srel = sreloc;
2527                   rent->rtype = r_type;
2528                   rent->count = 1;
2529                   rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
2530                                    == (SEC_READONLY | SEC_ALLOC));
2531
2532                   rent->next = h->reloc_entries;
2533                   h->reloc_entries = rent;
2534                 }
2535               else
2536                 rent->count++;
2537             }
2538           else if (info->shared && (sec->flags & SEC_ALLOC))
2539             {
2540               /* If this is a shared library, and the section is to be
2541                  loaded into memory, we need a RELATIVE reloc.  */
2542               sreloc->_raw_size += sizeof (Elf64_External_Rela);
2543               if (sec->flags & SEC_READONLY)
2544                 info->flags |= DF_TEXTREL;
2545             }
2546           break;
2547         }
2548     }
2549
2550   return true;
2551 }
2552
2553 /* Adjust a symbol defined by a dynamic object and referenced by a
2554    regular object.  The current definition is in some section of the
2555    dynamic object, but we're not including those sections.  We have to
2556    change the definition to something the rest of the link can
2557    understand.  */
2558
2559 static boolean
2560 elf64_alpha_adjust_dynamic_symbol (info, h)
2561      struct bfd_link_info *info;
2562      struct elf_link_hash_entry *h;
2563 {
2564   bfd *dynobj;
2565   asection *s;
2566   struct alpha_elf_link_hash_entry *ah;
2567
2568   dynobj = elf_hash_table(info)->dynobj;
2569   ah = (struct alpha_elf_link_hash_entry *)h;
2570
2571   /* Now that we've seen all of the input symbols, finalize our decision
2572      about whether this symbol should get a .plt entry.  */
2573
2574   if (alpha_elf_dynamic_symbol_p (h, info)
2575       && ((h->type == STT_FUNC
2576            && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2577           || (h->type == STT_NOTYPE
2578               && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2579       /* Don't prevent otherwise valid programs from linking by attempting
2580          to create a new .got entry somewhere.  A Correct Solution would be
2581          to add a new .got section to a new object file and let it be merged
2582          somewhere later.  But for now don't bother.  */
2583       && ah->got_entries)
2584     {
2585       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2586
2587       s = bfd_get_section_by_name(dynobj, ".plt");
2588       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2589         return false;
2590
2591       /* The first bit of the .plt is reserved.  */
2592       if (s->_raw_size == 0)
2593         s->_raw_size = PLT_HEADER_SIZE;
2594
2595       h->plt.offset = s->_raw_size;
2596       s->_raw_size += PLT_ENTRY_SIZE;
2597
2598       /* If this symbol is not defined in a regular file, and we are not
2599          generating a shared library, then set the symbol to the location
2600          in the .plt.  This is required to make function pointers compare
2601          equal between the normal executable and the shared library.  */
2602       if (! info->shared
2603           && h->root.type != bfd_link_hash_defweak)
2604         {
2605           h->root.u.def.section = s;
2606           h->root.u.def.value = h->plt.offset;
2607         }
2608
2609       /* We also need a JMP_SLOT entry in the .rela.plt section.  */
2610       s = bfd_get_section_by_name (dynobj, ".rela.plt");
2611       BFD_ASSERT (s != NULL);
2612       s->_raw_size += sizeof (Elf64_External_Rela);
2613
2614       return true;
2615     }
2616   else
2617     h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2618
2619   /* If this is a weak symbol, and there is a real definition, the
2620      processor independent code will have arranged for us to see the
2621      real definition first, and we can just use the same value.  */
2622   if (h->weakdef != NULL)
2623     {
2624       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2625                   || h->weakdef->root.type == bfd_link_hash_defweak);
2626       h->root.u.def.section = h->weakdef->root.u.def.section;
2627       h->root.u.def.value = h->weakdef->root.u.def.value;
2628       return true;
2629     }
2630
2631   /* This is a reference to a symbol defined by a dynamic object which
2632      is not a function.  The Alpha, since it uses .got entries for all
2633      symbols even in regular objects, does not need the hackery of a
2634      .dynbss section and COPY dynamic relocations.  */
2635
2636   return true;
2637 }
2638
2639 /* Symbol versioning can create new symbols, and make our old symbols
2640    indirect to the new ones.  Consolidate the got and reloc information
2641    in these situations.  */
2642
2643 static boolean
2644 elf64_alpha_merge_ind_symbols (hi, dummy)
2645      struct alpha_elf_link_hash_entry *hi;
2646      PTR dummy ATTRIBUTE_UNUSED;
2647 {
2648   struct alpha_elf_link_hash_entry *hs;
2649
2650   if (hi->root.root.type != bfd_link_hash_indirect)
2651     return true;
2652   hs = hi;
2653   do {
2654     hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2655   } while (hs->root.root.type == bfd_link_hash_indirect);
2656
2657   /* Merge the flags.  Whee.  */
2658
2659   hs->flags |= hi->flags;
2660
2661   /* Merge the .got entries.  Cannibalize the old symbol's list in
2662      doing so, since we don't need it anymore.  */
2663
2664   if (hs->got_entries == NULL)
2665     hs->got_entries = hi->got_entries;
2666   else
2667     {
2668       struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2669
2670       gsh = hs->got_entries;
2671       for (gi = hi->got_entries; gi ; gi = gin)
2672         {
2673           gin = gi->next;
2674           for (gs = gsh; gs ; gs = gs->next)
2675             if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2676               goto got_found;
2677           gi->next = hs->got_entries;
2678           hs->got_entries = gi;
2679         got_found:;
2680         }
2681     }
2682   hi->got_entries = NULL;
2683
2684   /* And similar for the reloc entries.  */
2685
2686   if (hs->reloc_entries == NULL)
2687     hs->reloc_entries = hi->reloc_entries;
2688   else
2689     {
2690       struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2691
2692       rsh = hs->reloc_entries;
2693       for (ri = hi->reloc_entries; ri ; ri = rin)
2694         {
2695           rin = ri->next;
2696           for (rs = rsh; rs ; rs = rs->next)
2697             if (ri->rtype == rs->rtype)
2698               {
2699                 rs->count += ri->count;
2700                 goto found_reloc;
2701               }
2702           ri->next = hs->reloc_entries;
2703           hs->reloc_entries = ri;
2704         found_reloc:;
2705         }
2706     }
2707   hi->reloc_entries = NULL;
2708
2709   return true;
2710 }
2711
2712 /* Is it possible to merge two object file's .got tables?  */
2713
2714 static boolean
2715 elf64_alpha_can_merge_gots (a, b)
2716      bfd *a, *b;
2717 {
2718   int total = alpha_elf_tdata (a)->total_got_entries;
2719   bfd *bsub;
2720
2721   /* Trivial quick fallout test.  */
2722   if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2723     return true;
2724
2725   /* By their nature, local .got entries cannot be merged.  */
2726   if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2727     return false;
2728
2729   /* Failing the common trivial comparison, we must effectively
2730      perform the merge.  Not actually performing the merge means that
2731      we don't have to store undo information in case we fail.  */
2732   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2733     {
2734       struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2735       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2736       int i, n;
2737
2738       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2739       for (i = 0; i < n; ++i)
2740         {
2741           struct alpha_elf_got_entry *ae, *be;
2742           struct alpha_elf_link_hash_entry *h;
2743
2744           h = hashes[i];
2745           while (h->root.root.type == bfd_link_hash_indirect
2746                  || h->root.root.type == bfd_link_hash_warning)
2747             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2748
2749           for (be = h->got_entries; be ; be = be->next)
2750             {
2751               if (be->use_count == 0)
2752                 continue;
2753               if (be->gotobj != b)
2754                 continue;
2755
2756               for (ae = h->got_entries; ae ; ae = ae->next)
2757                 if (ae->gotobj == a && ae->addend == be->addend)
2758                   goto global_found;
2759
2760               if (++total > MAX_GOT_ENTRIES)
2761                 return false;
2762             global_found:;
2763             }
2764         }
2765     }
2766
2767   return true;
2768 }
2769
2770 /* Actually merge two .got tables.  */
2771
2772 static void
2773 elf64_alpha_merge_gots (a, b)
2774      bfd *a, *b;
2775 {
2776   int total = alpha_elf_tdata (a)->total_got_entries;
2777   bfd *bsub;
2778
2779   /* Remember local expansion.  */
2780   {
2781     int e = alpha_elf_tdata (b)->n_local_got_entries;
2782     total += e;
2783     alpha_elf_tdata (a)->n_local_got_entries += e;
2784   }
2785
2786   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2787     {
2788       struct alpha_elf_got_entry **local_got_entries;
2789       struct alpha_elf_link_hash_entry **hashes;
2790       Elf_Internal_Shdr *symtab_hdr;
2791       int i, n;
2792
2793       /* Let the local .got entries know they are part of a new subsegment.  */
2794       local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2795       if (local_got_entries)
2796         {
2797           n = elf_tdata (bsub)->symtab_hdr.sh_info;
2798           for (i = 0; i < n; ++i)
2799             {
2800               struct alpha_elf_got_entry *ent;
2801               for (ent = local_got_entries[i]; ent; ent = ent->next)
2802                 ent->gotobj = a;
2803             }
2804         }
2805
2806       /* Merge the global .got entries.  */
2807       hashes = alpha_elf_sym_hashes (bsub);
2808       symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2809
2810       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2811       for (i = 0; i < n; ++i)
2812         {
2813           struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2814           struct alpha_elf_link_hash_entry *h;
2815
2816           h = hashes[i];
2817           while (h->root.root.type == bfd_link_hash_indirect
2818                  || h->root.root.type == bfd_link_hash_warning)
2819             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2820
2821           start = &h->got_entries;
2822           for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2823             {
2824               if (be->use_count == 0)
2825                 {
2826                   *pbe = be->next;
2827                   continue;
2828                 }
2829               if (be->gotobj != b)
2830                 continue;
2831
2832               for (ae = *start; ae ; ae = ae->next)
2833                 if (ae->gotobj == a && ae->addend == be->addend)
2834                   {
2835                     ae->flags |= be->flags;
2836                     ae->use_count += be->use_count;
2837                     *pbe = be->next;
2838                     goto global_found;
2839                   }
2840               be->gotobj = a;
2841               total += 1;
2842
2843             global_found:;
2844             }
2845         }
2846
2847       alpha_elf_tdata (bsub)->gotobj = a;
2848     }
2849   alpha_elf_tdata (a)->total_got_entries = total;
2850
2851   /* Merge the two in_got chains.  */
2852   {
2853     bfd *next;
2854
2855     bsub = a;
2856     while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2857       bsub = next;
2858
2859     alpha_elf_tdata (bsub)->in_got_link_next = b;
2860   }
2861 }
2862
2863 /* Calculate the offsets for the got entries.  */
2864
2865 static boolean
2866 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2867      struct alpha_elf_link_hash_entry *h;
2868      PTR arg ATTRIBUTE_UNUSED;
2869 {
2870   struct alpha_elf_got_entry *gotent;
2871
2872   if (h->root.root.type == bfd_link_hash_warning)
2873     h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2874
2875   for (gotent = h->got_entries; gotent; gotent = gotent->next)
2876     if (gotent->use_count > 0)
2877       {
2878         bfd_size_type *plge
2879           = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2880
2881         gotent->got_offset = *plge;
2882         *plge += 8;
2883       }
2884
2885   return true;
2886 }
2887
2888 static void
2889 elf64_alpha_calc_got_offsets (info)
2890      struct bfd_link_info *info;
2891 {
2892   bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2893
2894   /* First, zero out the .got sizes, as we may be recalculating the
2895      .got after optimizing it.  */
2896   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2897     alpha_elf_tdata(i)->got->_raw_size = 0;
2898
2899   /* Next, fill in the offsets for all the global entries.  */
2900   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2901                                 elf64_alpha_calc_got_offsets_for_symbol,
2902                                 NULL);
2903
2904   /* Finally, fill in the offsets for the local entries.  */
2905   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2906     {
2907       bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2908       bfd *j;
2909
2910       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2911         {
2912           struct alpha_elf_got_entry **local_got_entries, *gotent;
2913           int k, n;
2914
2915           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2916           if (!local_got_entries)
2917             continue;
2918
2919           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2920             for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2921               if (gotent->use_count > 0)
2922                 {
2923                   gotent->got_offset = got_offset;
2924                   got_offset += 8;
2925                 }
2926         }
2927
2928       alpha_elf_tdata(i)->got->_raw_size = got_offset;
2929       alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2930     }
2931 }
2932
2933 /* Constructs the gots.  */
2934
2935 static boolean
2936 elf64_alpha_size_got_sections (output_bfd, info)
2937      bfd *output_bfd ATTRIBUTE_UNUSED;
2938      struct bfd_link_info *info;
2939 {
2940   bfd *i, *got_list, *cur_got_obj = NULL;
2941   int something_changed = 0;
2942
2943   got_list = alpha_elf_hash_table (info)->got_list;
2944
2945   /* On the first time through, pretend we have an existing got list
2946      consisting of all of the input files.  */
2947   if (got_list == NULL)
2948     {
2949       for (i = info->input_bfds; i ; i = i->link_next)
2950         {
2951           bfd *this_got = alpha_elf_tdata (i)->gotobj;
2952           if (this_got == NULL)
2953             continue;
2954
2955           /* We are assuming no merging has yet ocurred.  */
2956           BFD_ASSERT (this_got == i);
2957
2958           if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2959             {
2960               /* Yikes! A single object file has too many entries.  */
2961               (*_bfd_error_handler)
2962                 (_("%s: .got subsegment exceeds 64K (size %d)"),
2963                  bfd_archive_filename (i),
2964                  alpha_elf_tdata (this_got)->total_got_entries * 8);
2965               return false;
2966             }
2967
2968           if (got_list == NULL)
2969             got_list = this_got;
2970           else
2971             alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2972           cur_got_obj = this_got;
2973         }
2974
2975       /* Strange degenerate case of no got references.  */
2976       if (got_list == NULL)
2977         return true;
2978
2979       alpha_elf_hash_table (info)->got_list = got_list;
2980
2981       /* Force got offsets to be recalculated.  */
2982       something_changed = 1;
2983     }
2984
2985   cur_got_obj = got_list;
2986   i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2987   while (i != NULL)
2988     {
2989       if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2990         {
2991           elf64_alpha_merge_gots (cur_got_obj, i);
2992           i = alpha_elf_tdata(i)->got_link_next;
2993           alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2994           something_changed = 1;
2995         }
2996       else
2997         {
2998           cur_got_obj = i;
2999           i = alpha_elf_tdata(i)->got_link_next;
3000         }
3001     }
3002
3003   /* Once the gots have been merged, fill in the got offsets for
3004      everything therein.  */
3005   if (1 || something_changed)
3006     elf64_alpha_calc_got_offsets (info);
3007
3008   return true;
3009 }
3010
3011 static boolean
3012 elf64_alpha_always_size_sections (output_bfd, info)
3013      bfd *output_bfd;
3014      struct bfd_link_info *info;
3015 {
3016   bfd *i;
3017
3018   if (info->relocateable)
3019     return true;
3020
3021   /* First, take care of the indirect symbols created by versioning.  */
3022   alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3023                                 elf64_alpha_merge_ind_symbols,
3024                                 NULL);
3025
3026   if (!elf64_alpha_size_got_sections (output_bfd, info))
3027     return false;
3028
3029   /* Allocate space for all of the .got subsections.  */
3030   i = alpha_elf_hash_table (info)->got_list;
3031   for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3032     {
3033       asection *s = alpha_elf_tdata(i)->got;
3034       if (s->_raw_size > 0)
3035         {
3036           s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3037           if (s->contents == NULL)
3038             return false;
3039         }
3040     }
3041
3042   return true;
3043 }
3044
3045 /* Work out the sizes of the dynamic relocation entries.  */
3046
3047 static boolean
3048 elf64_alpha_calc_dynrel_sizes (h, info)
3049      struct alpha_elf_link_hash_entry *h;
3050      struct bfd_link_info *info;
3051 {
3052   if (h->root.root.type == bfd_link_hash_warning)
3053     h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3054
3055   /* If the symbol was defined as a common symbol in a regular object
3056      file, and there was no definition in any dynamic object, then the
3057      linker will have allocated space for the symbol in a common
3058      section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3059      set.  This is done for dynamic symbols in
3060      elf_adjust_dynamic_symbol but this is not done for non-dynamic
3061      symbols, somehow.  */
3062   if (((h->root.elf_link_hash_flags
3063        & (ELF_LINK_HASH_DEF_REGULAR
3064           | ELF_LINK_HASH_REF_REGULAR
3065           | ELF_LINK_HASH_DEF_DYNAMIC))
3066        == ELF_LINK_HASH_REF_REGULAR)
3067       && (h->root.root.type == bfd_link_hash_defined
3068           || h->root.root.type == bfd_link_hash_defweak)
3069       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3070     {
3071       h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3072     }
3073
3074   /* If the symbol is dynamic, we'll need all the relocations in their
3075      natural form.  If this is a shared object, and it has been forced
3076      local, we'll need the same number of RELATIVE relocations.  */
3077
3078   if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3079     {
3080       struct alpha_elf_reloc_entry *relent;
3081       bfd *dynobj;
3082       struct alpha_elf_got_entry *gotent;
3083       bfd_size_type count;
3084       asection *srel;
3085
3086       for (relent = h->reloc_entries; relent; relent = relent->next)
3087         if (relent->rtype == R_ALPHA_REFLONG
3088             || relent->rtype == R_ALPHA_REFQUAD)
3089           {
3090             relent->srel->_raw_size +=
3091               sizeof (Elf64_External_Rela) * relent->count;
3092             if (relent->reltext)
3093               info->flags |= DT_TEXTREL;
3094           }
3095
3096       dynobj = elf_hash_table(info)->dynobj;
3097       count = 0;
3098
3099       for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3100         count++;
3101
3102       /* If we are using a .plt entry, subtract one, as the first
3103          reference uses a .rela.plt entry instead.  */
3104       if (h->root.plt.offset != MINUS_ONE)
3105         count--;
3106
3107       if (count > 0)
3108         {
3109           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3110           BFD_ASSERT (srel != NULL);
3111           srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3112         }
3113     }
3114
3115   return true;
3116 }
3117
3118 /* Set the sizes of the dynamic sections.  */
3119
3120 static boolean
3121 elf64_alpha_size_dynamic_sections (output_bfd, info)
3122      bfd *output_bfd ATTRIBUTE_UNUSED;
3123      struct bfd_link_info *info;
3124 {
3125   bfd *dynobj;
3126   asection *s;
3127   boolean relplt;
3128
3129   dynobj = elf_hash_table(info)->dynobj;
3130   BFD_ASSERT(dynobj != NULL);
3131
3132   if (elf_hash_table (info)->dynamic_sections_created)
3133     {
3134       /* Set the contents of the .interp section to the interpreter.  */
3135       if (!info->shared)
3136         {
3137           s = bfd_get_section_by_name (dynobj, ".interp");
3138           BFD_ASSERT (s != NULL);
3139           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3140           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3141         }
3142
3143       /* Now that we've seen all of the input files, we can decide which
3144          symbols need dynamic relocation entries and which don't.  We've
3145          collected information in check_relocs that we can now apply to
3146          size the dynamic relocation sections.  */
3147       alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3148                                     elf64_alpha_calc_dynrel_sizes,
3149                                     info);
3150
3151       /* When building shared libraries, each local .got entry needs a
3152          RELATIVE reloc.  */
3153       if (info->shared)
3154         {
3155           bfd *i;
3156           asection *srel;
3157           bfd_size_type count;
3158
3159           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3160           BFD_ASSERT (srel != NULL);
3161
3162           for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3163                i != NULL;
3164                i = alpha_elf_tdata(i)->got_link_next)
3165             count += alpha_elf_tdata(i)->n_local_got_entries;
3166
3167           srel->_raw_size += count * sizeof (Elf64_External_Rela);
3168         }
3169     }
3170   /* else we're not dynamic and by definition we don't need such things.  */
3171
3172   /* The check_relocs and adjust_dynamic_symbol entry points have
3173      determined the sizes of the various dynamic sections.  Allocate
3174      memory for them.  */
3175   relplt = false;
3176   for (s = dynobj->sections; s != NULL; s = s->next)
3177     {
3178       const char *name;
3179       boolean strip;
3180
3181       if (!(s->flags & SEC_LINKER_CREATED))
3182         continue;
3183
3184       /* It's OK to base decisions on the section name, because none
3185          of the dynobj section names depend upon the input files.  */
3186       name = bfd_get_section_name (dynobj, s);
3187
3188       /* If we don't need this section, strip it from the output file.
3189          This is to handle .rela.bss and .rela.plt.  We must create it
3190          in create_dynamic_sections, because it must be created before
3191          the linker maps input sections to output sections.  The
3192          linker does that before adjust_dynamic_symbol is called, and
3193          it is that function which decides whether anything needs to
3194          go into these sections.  */
3195
3196       strip = false;
3197
3198       if (strncmp (name, ".rela", 5) == 0)
3199         {
3200           strip = (s->_raw_size == 0);
3201
3202           if (!strip)
3203             {
3204               if (strcmp(name, ".rela.plt") == 0)
3205                 relplt = true;
3206
3207               /* We use the reloc_count field as a counter if we need
3208                  to copy relocs into the output file.  */
3209               s->reloc_count = 0;
3210             }
3211         }
3212       else if (strcmp (name, ".plt") != 0)
3213         {
3214           /* It's not one of our dynamic sections, so don't allocate space.  */
3215           continue;
3216         }
3217
3218       if (strip)
3219         _bfd_strip_section_from_output (info, s);
3220       else
3221         {
3222           /* Allocate memory for the section contents.  */
3223           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3224           if (s->contents == NULL && s->_raw_size != 0)
3225             return false;
3226         }
3227     }
3228
3229   if (elf_hash_table (info)->dynamic_sections_created)
3230     {
3231       /* Add some entries to the .dynamic section.  We fill in the
3232          values later, in elf64_alpha_finish_dynamic_sections, but we
3233          must add the entries now so that we get the correct size for
3234          the .dynamic section.  The DT_DEBUG entry is filled in by the
3235          dynamic linker and used by the debugger.  */
3236 #define add_dynamic_entry(TAG, VAL) \
3237   bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3238
3239       if (!info->shared)
3240         {
3241           if (!add_dynamic_entry (DT_DEBUG, 0))
3242             return false;
3243         }
3244
3245       if (relplt)
3246         {
3247           if (!add_dynamic_entry (DT_PLTGOT, 0)
3248               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3249               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3250               || !add_dynamic_entry (DT_JMPREL, 0))
3251             return false;
3252         }
3253
3254       if (!add_dynamic_entry (DT_RELA, 0)
3255           || !add_dynamic_entry (DT_RELASZ, 0)
3256           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3257         return false;
3258
3259       if (info->flags & DF_TEXTREL)
3260         {
3261           if (!add_dynamic_entry (DT_TEXTREL, 0))
3262             return false;
3263         }
3264     }
3265 #undef add_dynamic_entry
3266
3267   return true;
3268 }
3269
3270 /* Relocate an Alpha ELF section.  */
3271
3272 static boolean
3273 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3274                               contents, relocs, local_syms, local_sections)
3275      bfd *output_bfd;
3276      struct bfd_link_info *info;
3277      bfd *input_bfd;
3278      asection *input_section;
3279      bfd_byte *contents;
3280      Elf_Internal_Rela *relocs;
3281      Elf_Internal_Sym *local_syms;
3282      asection **local_sections;
3283 {
3284   Elf_Internal_Shdr *symtab_hdr;
3285   Elf_Internal_Rela *rel;
3286   Elf_Internal_Rela *relend;
3287   asection *sec, *sgot, *srel, *srelgot;
3288   bfd *dynobj, *gotobj;
3289   bfd_vma gp;
3290   boolean ret_val = true;
3291
3292   srelgot = srel = NULL;
3293   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3294   dynobj = elf_hash_table (info)->dynobj;
3295   if (dynobj)
3296     {
3297       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3298     }
3299
3300   /* Find the gp value for this input bfd.  */
3301   sgot = NULL;
3302   gp = 0;
3303   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3304   if (gotobj)
3305     {
3306       sgot = alpha_elf_tdata (gotobj)->got;
3307       gp = _bfd_get_gp_value (gotobj);
3308       if (gp == 0)
3309         {
3310           gp = (sgot->output_section->vma
3311                 + sgot->output_offset
3312                 + 0x8000);
3313           _bfd_set_gp_value (gotobj, gp);
3314         }
3315     }
3316
3317   rel = relocs;
3318   relend = relocs + input_section->reloc_count;
3319   for (; rel < relend; rel++)
3320     {
3321       int r_type;
3322       reloc_howto_type *howto;
3323       unsigned long r_symndx;
3324       struct alpha_elf_link_hash_entry *h;
3325       Elf_Internal_Sym *sym;
3326       bfd_vma relocation;
3327       bfd_vma addend;
3328       bfd_reloc_status_type r;
3329
3330       r_type = ELF64_R_TYPE(rel->r_info);
3331       if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3332         {
3333           bfd_set_error (bfd_error_bad_value);
3334           return false;
3335         }
3336       howto = elf64_alpha_howto_table + r_type;
3337
3338       r_symndx = ELF64_R_SYM(rel->r_info);
3339
3340       if (info->relocateable)
3341         {
3342           /* This is a relocateable link.  We don't have to change
3343              anything, unless the reloc is against a section symbol,
3344              in which case we have to adjust according to where the
3345              section symbol winds up in the output section.  */
3346
3347           /* The symbol associated with GPDISP and LITUSE is
3348              immaterial.  Only the addend is significant.  */
3349           if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3350             continue;
3351
3352           if (r_symndx < symtab_hdr->sh_info)
3353             {
3354               sym = local_syms + r_symndx;
3355               if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3356                 {
3357                   sec = local_sections[r_symndx];
3358                   rel->r_addend += sec->output_offset + sym->st_value;
3359                 }
3360             }
3361
3362           continue;
3363         }
3364
3365       /* This is a final link.  */
3366
3367       h = NULL;
3368       sym = NULL;
3369       sec = NULL;
3370
3371       if (r_symndx < symtab_hdr->sh_info)
3372         {
3373           sym = local_syms + r_symndx;
3374           sec = local_sections[r_symndx];
3375           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3376         }
3377       else
3378         {
3379           h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3380
3381           while (h->root.root.type == bfd_link_hash_indirect
3382                  || h->root.root.type == bfd_link_hash_warning)
3383             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3384
3385           if (h->root.root.type == bfd_link_hash_defined
3386               || h->root.root.type == bfd_link_hash_defweak)
3387             {
3388               sec = h->root.root.u.def.section;
3389
3390               if (sec->output_section == NULL)
3391                 relocation = 0;
3392               else
3393                 {
3394                   relocation = (h->root.root.u.def.value
3395                                 + sec->output_section->vma
3396                                 + sec->output_offset);
3397                 }
3398             }
3399           else if (h->root.root.type == bfd_link_hash_undefweak)
3400             relocation = 0;
3401           else if (info->shared
3402                    && (!info->symbolic || info->allow_shlib_undefined)
3403                    && !info->no_undefined
3404                    && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3405             relocation = 0;
3406           else
3407             {
3408               if (!((*info->callbacks->undefined_symbol)
3409                     (info, h->root.root.root.string, input_bfd,
3410                      input_section, rel->r_offset,
3411                      (!info->shared || info->no_undefined
3412                       || ELF_ST_VISIBILITY (h->root.other)))))
3413                 ret_val = false;
3414               relocation = 0;
3415             }
3416         }
3417       addend = rel->r_addend;
3418
3419       switch (r_type)
3420         {
3421         case R_ALPHA_GPDISP:
3422           {
3423             bfd_byte *p_ldah, *p_lda;
3424
3425             BFD_ASSERT(gp != 0);
3426
3427             relocation = (input_section->output_section->vma
3428                           + input_section->output_offset
3429                           + rel->r_offset);
3430
3431             p_ldah = contents + rel->r_offset - input_section->vma;
3432             p_lda = p_ldah + rel->r_addend;
3433
3434             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3435                                              p_ldah, p_lda);
3436           }
3437           break;
3438
3439         case R_ALPHA_LITERAL:
3440           {
3441             struct alpha_elf_got_entry *gotent;
3442             boolean dynamic_symbol;
3443
3444             BFD_ASSERT(sgot != NULL);
3445             BFD_ASSERT(gp != 0);
3446
3447             if (h != NULL)
3448               {
3449                 gotent = h->got_entries;
3450                 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3451               }
3452             else
3453               {
3454                 gotent = (alpha_elf_tdata(input_bfd)->
3455                           local_got_entries[r_symndx]);
3456                 dynamic_symbol = false;
3457
3458                 /* Need to adjust local GOT entries' addends for SEC_MERGE
3459                    unless it has been done already.  */
3460                 if ((sec->flags & SEC_MERGE)
3461                     && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3462                     && (elf_section_data (sec)->sec_info_type
3463                         == ELF_INFO_TYPE_MERGE)
3464                     && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3465                   {
3466                     struct alpha_elf_got_entry *ent;
3467                     asection *msec;
3468
3469                     for (ent = gotent; ent; ent = ent->next)
3470                       {
3471                         ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3472                         if (ent->use_count == 0)
3473                           continue;
3474                         msec = sec;
3475                         ent->addend =
3476                           _bfd_merged_section_offset (output_bfd, &msec,
3477                                                       elf_section_data (sec)->
3478                                                       sec_info,
3479                                                       sym->st_value
3480                                                       + ent->addend,
3481                                                       (bfd_vma) 0);
3482                         ent->addend -= sym->st_value;
3483                         ent->addend += msec->output_section->vma
3484                                        + msec->output_offset
3485                                        - sec->output_section->vma
3486                                        - sec->output_offset;
3487                       }
3488                   }
3489               }
3490
3491             BFD_ASSERT(gotent != NULL);
3492
3493             while (gotent->gotobj != gotobj || gotent->addend != addend)
3494               gotent = gotent->next;
3495
3496             BFD_ASSERT(gotent->use_count >= 1);
3497
3498             /* Initialize the .got entry's value.  */
3499             if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3500               {
3501                 bfd_put_64 (output_bfd, relocation + addend,
3502                             sgot->contents + gotent->got_offset);
3503
3504                 /* If the symbol has been forced local, output a
3505                    RELATIVE reloc, otherwise it will be handled in
3506                    finish_dynamic_symbol.  */
3507                 if (info->shared && !dynamic_symbol)
3508                   {
3509                     Elf_Internal_Rela outrel;
3510
3511                     BFD_ASSERT(srelgot != NULL);
3512
3513                     outrel.r_offset = (sgot->output_section->vma
3514                                        + sgot->output_offset
3515                                        + gotent->got_offset);
3516                     outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3517                     outrel.r_addend = relocation + addend;
3518
3519                     bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3520                                                ((Elf64_External_Rela *)
3521                                                 srelgot->contents)
3522                                                + srelgot->reloc_count++);
3523                     BFD_ASSERT (sizeof (Elf64_External_Rela)
3524                                 * srelgot->reloc_count
3525                                 <= srelgot->_cooked_size);
3526                   }
3527
3528                 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3529               }
3530
3531             /* Figure the gprel relocation.  */
3532             addend = 0;
3533             relocation = (sgot->output_section->vma
3534                           + sgot->output_offset
3535                           + gotent->got_offset);
3536             relocation -= gp;
3537           }
3538           /* overflow handled by _bfd_final_link_relocate */
3539           goto default_reloc;
3540
3541         case R_ALPHA_GPREL16:
3542         case R_ALPHA_GPREL32:
3543         case R_ALPHA_GPRELLOW:
3544           if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3545             {
3546               (*_bfd_error_handler)
3547                 (_("%s: gp-relative relocation against dynamic symbol %s"),
3548                  bfd_archive_filename (input_bfd), h->root.root.root.string);
3549               ret_val = false;
3550             }
3551           BFD_ASSERT(gp != 0);
3552           relocation -= gp;
3553           goto default_reloc;
3554
3555         case R_ALPHA_GPRELHIGH:
3556           if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3557             {
3558               (*_bfd_error_handler)
3559                 (_("%s: gp-relative relocation against dynamic symbol %s"),
3560                  bfd_archive_filename (input_bfd), h->root.root.root.string);
3561               ret_val = false;
3562             }
3563           BFD_ASSERT(gp != 0);
3564           relocation -= gp;
3565           relocation += addend;
3566           addend = 0;
3567           relocation = (((bfd_signed_vma) relocation >> 16)
3568                         + ((relocation >> 15) & 1));
3569           goto default_reloc;
3570
3571         case R_ALPHA_HINT:
3572           /* A call to a dynamic symbol is definitely out of range of
3573              the 16-bit displacement.  Don't bother writing anything.  */
3574           if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3575             {
3576               r = bfd_reloc_ok;
3577               break;
3578             }
3579           /* FALLTHRU */
3580
3581         case R_ALPHA_BRADDR:
3582           /* The regular PC-relative stuff measures from the start of
3583              the instruction rather than the end.  */
3584           addend -= 4;
3585           goto default_reloc;
3586
3587         case R_ALPHA_BRSGP:
3588           {
3589             int other;
3590             const char *name;
3591
3592             /* The regular PC-relative stuff measures from the start of
3593                the instruction rather than the end.  */
3594             addend -= 4;
3595
3596             /* The source and destination gp must be the same.  Note that
3597                the source will always have an assigned gp, since we forced
3598                one in check_relocs, but that the destination may not, as
3599                it might not have had any relocations at all.  Also take 
3600                care not to crash if H is an undefined symbol.  */
3601             if (h != NULL && sec != NULL
3602                 && alpha_elf_tdata (sec->owner)->gotobj
3603                 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
3604               {
3605                 (*_bfd_error_handler)
3606                   (_("%s: change in gp: BRSGP %s"),
3607                    bfd_archive_filename (input_bfd), h->root.root.root.string);
3608                 ret_val = false;
3609               }
3610
3611             /* The symbol should be marked either NOPV or STD_GPLOAD.  */
3612             if (h != NULL)
3613               other = h->root.other;
3614             else
3615               other = sym->st_other;
3616             switch (other & STO_ALPHA_STD_GPLOAD)
3617               {
3618               case STO_ALPHA_NOPV:
3619                 break;
3620               case STO_ALPHA_STD_GPLOAD:
3621                 addend += 8;
3622                 break;
3623               default:
3624                 if (h != NULL)
3625                   name = h->root.root.root.string;
3626                 else
3627                   {
3628                     name = (bfd_elf_string_from_elf_section
3629                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
3630                     if (name == NULL)
3631                       name = _("<unknown>");
3632                     else if (name[0] == 0)
3633                       name = bfd_section_name (input_bfd, sec);
3634                   }
3635                 (*_bfd_error_handler)
3636                   (_("%s: !samegp reloc against symbol without .prologue: %s"),
3637                    bfd_archive_filename (input_bfd), name);
3638                 ret_val = false;
3639                 break;
3640               }
3641
3642             goto default_reloc;
3643           }
3644
3645         case R_ALPHA_REFLONG:
3646         case R_ALPHA_REFQUAD:
3647           {
3648             Elf_Internal_Rela outrel;
3649
3650             /* Careful here to remember RELATIVE relocations for global
3651                variables for symbolic shared objects.  */
3652
3653             if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3654               {
3655                 BFD_ASSERT(h->root.dynindx != -1);
3656                 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3657                 outrel.r_addend = addend;
3658                 addend = 0, relocation = 0;
3659               }
3660             else if (info->shared
3661                      && r_symndx != 0
3662                      && (input_section->flags & SEC_ALLOC))
3663               {
3664                 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3665                 outrel.r_addend = relocation + addend;
3666               }
3667             else
3668               goto default_reloc;
3669
3670             if (!srel)
3671               {
3672                 const char *name;
3673
3674                 name = (bfd_elf_string_from_elf_section
3675                         (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3676                          elf_section_data(input_section)->rel_hdr.sh_name));
3677                 BFD_ASSERT(name != NULL);
3678
3679                 srel = bfd_get_section_by_name (dynobj, name);
3680                 BFD_ASSERT(srel != NULL);
3681               }
3682
3683             outrel.r_offset =
3684               _bfd_elf_section_offset (output_bfd, info, input_section,
3685                                        rel->r_offset);
3686             if ((outrel.r_offset | 1) != (bfd_vma) -1)
3687               outrel.r_offset += (input_section->output_section->vma
3688                                   + input_section->output_offset);
3689             else
3690               memset (&outrel, 0, sizeof outrel);
3691
3692             bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3693                                        ((Elf64_External_Rela *)
3694                                         srel->contents)
3695                                        + srel->reloc_count++);
3696             BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3697                         <= srel->_cooked_size);
3698           }
3699           goto default_reloc;
3700
3701         case R_ALPHA_SREL32:
3702         case R_ALPHA_SREL64:
3703           /* ??? .eh_frame references to discarded sections will be smashed
3704              to relocations against SHN_UNDEF.  The .eh_frame format allows
3705              NULL to be encoded as 0 in any format, so this works here.  */
3706           if (r_symndx == 0)
3707             howto = (elf64_alpha_howto_table
3708                      + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
3709           goto default_reloc;
3710
3711         default:
3712         default_reloc:
3713           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3714                                         contents, rel->r_offset, relocation,
3715                                         addend);
3716           break;
3717         }
3718
3719       switch (r)
3720         {
3721         case bfd_reloc_ok:
3722           break;
3723
3724         case bfd_reloc_overflow:
3725           {
3726             const char *name;
3727
3728             /* Don't warn if the overflow is due to pc relative reloc
3729                against discarded section.  Section optimization code should
3730                handle it.  */
3731
3732             if (r_symndx < symtab_hdr->sh_info
3733                 && sec != NULL && howto->pc_relative
3734                 && elf_discarded_section (sec))
3735               break;
3736
3737             if (h != NULL)
3738               name = h->root.root.root.string;
3739             else
3740               {
3741                 name = (bfd_elf_string_from_elf_section
3742                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
3743                 if (name == NULL)
3744                   return false;
3745                 if (*name == '\0')
3746                   name = bfd_section_name (input_bfd, sec);
3747               }
3748             if (! ((*info->callbacks->reloc_overflow)
3749                    (info, name, howto->name, (bfd_vma) 0,
3750                     input_bfd, input_section, rel->r_offset)))
3751               ret_val = false;
3752           }
3753           break;
3754
3755         default:
3756         case bfd_reloc_outofrange:
3757           abort ();
3758         }
3759     }
3760
3761   return ret_val;
3762 }
3763
3764 /* Finish up dynamic symbol handling.  We set the contents of various
3765    dynamic sections here.  */
3766
3767 static boolean
3768 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3769      bfd *output_bfd;
3770      struct bfd_link_info *info;
3771      struct elf_link_hash_entry *h;
3772      Elf_Internal_Sym *sym;
3773 {
3774   bfd *dynobj = elf_hash_table(info)->dynobj;
3775
3776   if (h->plt.offset != MINUS_ONE)
3777     {
3778       /* Fill in the .plt entry for this symbol.  */
3779       asection *splt, *sgot, *srel;
3780       Elf_Internal_Rela outrel;
3781       bfd_vma got_addr, plt_addr;
3782       bfd_vma plt_index;
3783       struct alpha_elf_got_entry *gotent;
3784
3785       BFD_ASSERT (h->dynindx != -1);
3786
3787       /* The first .got entry will be updated by the .plt with the
3788          address of the target function.  */
3789       gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3790       BFD_ASSERT (gotent && gotent->addend == 0);
3791
3792       splt = bfd_get_section_by_name (dynobj, ".plt");
3793       BFD_ASSERT (splt != NULL);
3794       srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3795       BFD_ASSERT (srel != NULL);
3796       sgot = alpha_elf_tdata (gotent->gotobj)->got;
3797       BFD_ASSERT (sgot != NULL);
3798
3799       got_addr = (sgot->output_section->vma
3800                   + sgot->output_offset
3801                   + gotent->got_offset);
3802       plt_addr = (splt->output_section->vma
3803                   + splt->output_offset
3804                   + h->plt.offset);
3805
3806       plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3807
3808       /* Fill in the entry in the procedure linkage table.  */
3809       {
3810         bfd_vma insn1, insn2, insn3;
3811
3812         insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3813         insn2 = PLT_ENTRY_WORD2;
3814         insn3 = PLT_ENTRY_WORD3;
3815
3816         bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3817         bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3818         bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3819       }
3820
3821       /* Fill in the entry in the .rela.plt section.  */
3822       outrel.r_offset = got_addr;
3823       outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3824       outrel.r_addend = 0;
3825
3826       bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3827                                  ((Elf64_External_Rela *)srel->contents
3828                                   + plt_index));
3829
3830       if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3831         {
3832           /* Mark the symbol as undefined, rather than as defined in the
3833              .plt section.  Leave the value alone.  */
3834           sym->st_shndx = SHN_UNDEF;
3835         }
3836
3837       /* Fill in the entries in the .got.  */
3838       bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3839
3840       /* Subsequent .got entries will continue to bounce through the .plt.  */
3841       if (gotent->next)
3842         {
3843           srel = bfd_get_section_by_name (dynobj, ".rela.got");
3844           BFD_ASSERT (! info->shared || srel != NULL);
3845
3846           gotent = gotent->next;
3847           do
3848             {
3849               sgot = alpha_elf_tdata(gotent->gotobj)->got;
3850               BFD_ASSERT(sgot != NULL);
3851               BFD_ASSERT(gotent->addend == 0);
3852
3853               bfd_put_64 (output_bfd, plt_addr,
3854                           sgot->contents + gotent->got_offset);
3855
3856               if (info->shared)
3857                 {
3858                   outrel.r_offset = (sgot->output_section->vma
3859                                      + sgot->output_offset
3860                                      + gotent->got_offset);
3861                   outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3862                   outrel.r_addend = plt_addr;
3863
3864                   bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3865                                              ((Elf64_External_Rela *)
3866                                               srel->contents)
3867                                              + srel->reloc_count++);
3868                   BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3869                               <= srel->_cooked_size);
3870                 }
3871
3872               gotent = gotent->next;
3873             }
3874           while (gotent != NULL);
3875         }
3876     }
3877   else if (alpha_elf_dynamic_symbol_p (h, info))
3878     {
3879       /* Fill in the dynamic relocations for this symbol's .got entries.  */
3880       asection *srel;
3881       Elf_Internal_Rela outrel;
3882       struct alpha_elf_got_entry *gotent;
3883
3884       srel = bfd_get_section_by_name (dynobj, ".rela.got");
3885       BFD_ASSERT (srel != NULL)