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