Automatic date update in version.in
[binutils-gdb.git] / bfd / elf64-alpha.c
bloba29913d9365b182d87acf4c68ff49e0fc0462fad
1 /* Alpha specific support for 64-bit ELF
2 Copyright (C) 1996-2024 Free Software Foundation, Inc.
3 Contributed by Richard Henderson <rth@tamu.edu>.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
23 /* We need a published ABI spec for this. Until one comes out, don't
24 assume this'll remain unchanged forever. */
26 #include "sysdep.h"
27 #include "bfd.h"
28 #include "libbfd.h"
29 #include "elf-bfd.h"
30 #include "ecoff-bfd.h"
32 #include "elf/alpha.h"
34 #define ALPHAECOFF
36 #define NO_COFF_RELOCS
37 #define NO_COFF_SYMBOLS
38 #define NO_COFF_LINENOS
40 /* Get the ECOFF swapping routines. Needed for the debug information. */
41 #include "coff/internal.h"
42 #include "coff/sym.h"
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/alpha.h"
46 #include "aout/ar.h"
47 #include "libcoff.h"
48 #include "libecoff.h"
49 #define ECOFF_64
50 #include "ecoffswap.h"
53 /* Instruction data for plt generation and relaxation. */
55 #define OP_LDA 0x08U
56 #define OP_LDAH 0x09U
57 #define OP_LDQ 0x29U
58 #define OP_BR 0x30U
59 #define OP_BSR 0x34U
61 #define INSN_LDA (OP_LDA << 26)
62 #define INSN_LDAH (OP_LDAH << 26)
63 #define INSN_LDQ (OP_LDQ << 26)
64 #define INSN_BR (OP_BR << 26)
66 #define INSN_ADDQ 0x40000400
67 #define INSN_RDUNIQ 0x0000009e
68 #define INSN_SUBQ 0x40000520
69 #define INSN_S4SUBQ 0x40000560
70 #define INSN_UNOP 0x2ffe0000
72 #define INSN_JSR 0x68004000
73 #define INSN_JMP 0x68000000
74 #define INSN_JSR_MASK 0xfc00c000
76 #define INSN_A(I,A) (I | ((unsigned) A << 21))
77 #define INSN_AB(I,A,B) (INSN_A (I, A) | (B << 16))
78 #define INSN_ABC(I,A,B,C) (INSN_A (I, A) | (B << 16) | C)
79 #define INSN_ABO(I,A,B,O) (INSN_A (I, A) | (B << 16) | ((O) & 0xffff))
80 #define INSN_AD(I,A,D) (INSN_A (I, A) | (((D) >> 2) & 0x1fffff))
82 /* PLT/GOT Stuff */
84 /* Set by ld emulation. Putting this into the link_info or hash structure
85 is simply working too hard. */
86 #ifdef USE_SECUREPLT
87 bool elf64_alpha_use_secureplt = true;
88 #else
89 bool elf64_alpha_use_secureplt = false;
90 #endif
92 #define OLD_PLT_HEADER_SIZE 32
93 #define OLD_PLT_ENTRY_SIZE 12
94 #define NEW_PLT_HEADER_SIZE 36
95 #define NEW_PLT_ENTRY_SIZE 4
97 #define PLT_HEADER_SIZE \
98 (elf64_alpha_use_secureplt ? NEW_PLT_HEADER_SIZE : OLD_PLT_HEADER_SIZE)
99 #define PLT_ENTRY_SIZE \
100 (elf64_alpha_use_secureplt ? NEW_PLT_ENTRY_SIZE : OLD_PLT_ENTRY_SIZE)
102 #define MAX_GOT_SIZE (64*1024)
104 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
107 /* Used to implement multiple .got subsections. */
108 struct alpha_elf_got_entry
110 struct alpha_elf_got_entry *next;
112 /* Which .got subsection? */
113 bfd *gotobj;
115 /* The addend in effect for this entry. */
116 bfd_vma addend;
118 /* The .got offset for this entry. */
119 int got_offset;
121 /* The .plt offset for this entry. */
122 int plt_offset;
124 /* How many references to this entry? */
125 int use_count;
127 /* The relocation type of this entry. */
128 unsigned char reloc_type;
130 /* How a LITERAL is used. */
131 unsigned char flags;
133 /* Have we initialized the dynamic relocation for this entry? */
134 unsigned char reloc_done;
136 /* Have we adjusted this entry for SEC_MERGE? */
137 unsigned char reloc_xlated;
140 struct alpha_elf_reloc_entry
142 struct alpha_elf_reloc_entry *next;
144 /* Which .reloc section? */
145 asection *srel;
147 /* Which section this relocation is against? */
148 asection *sec;
150 /* How many did we find? */
151 unsigned long count;
153 /* What kind of relocation? */
154 unsigned int rtype;
157 struct alpha_elf_link_hash_entry
159 struct elf_link_hash_entry root;
161 /* External symbol information. */
162 EXTR esym;
164 /* Cumulative flags for all the .got entries. */
165 int flags;
167 /* Contexts in which a literal was referenced. */
168 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
169 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
170 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
171 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
172 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
173 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
174 #define ALPHA_ELF_LINK_HASH_LU_JSRDIRECT 0x40
175 #define ALPHA_ELF_LINK_HASH_LU_PLT 0x38
176 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x80
178 /* Used to implement multiple .got subsections. */
179 struct alpha_elf_got_entry *got_entries;
181 /* Used to count non-got, non-plt relocations for delayed sizing
182 of relocation sections. */
183 struct alpha_elf_reloc_entry *reloc_entries;
186 /* Alpha ELF linker hash table. */
188 struct alpha_elf_link_hash_table
190 struct elf_link_hash_table root;
192 /* The head of a list of .got subsections linked through
193 alpha_elf_tdata(abfd)->got_link_next. */
194 bfd *got_list;
196 /* The most recent relax pass that we've seen. The GOTs
197 should be regenerated if this doesn't match. */
198 int relax_trip;
201 /* Look up an entry in a Alpha ELF linker hash table. */
203 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
204 ((struct alpha_elf_link_hash_entry *) \
205 elf_link_hash_lookup (&(table)->root, (string), (create), \
206 (copy), (follow)))
208 /* Traverse a Alpha ELF linker hash table. */
210 #define alpha_elf_link_hash_traverse(table, func, info) \
211 (elf_link_hash_traverse \
212 (&(table)->root, \
213 (bool (*) (struct elf_link_hash_entry *, void *)) (func), \
214 (info)))
216 /* Get the Alpha ELF linker hash table from a link_info structure. */
218 #define alpha_elf_hash_table(p) \
219 ((is_elf_hash_table ((p)->hash) \
220 && elf_hash_table_id (elf_hash_table (p)) == ALPHA_ELF_DATA) \
221 ? (struct alpha_elf_link_hash_table *) (p)->hash : NULL)
223 /* Get the object's symbols as our own entry type. */
225 #define alpha_elf_sym_hashes(abfd) \
226 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
228 /* Should we do dynamic things to this symbol? This differs from the
229 generic version in that we never need to consider function pointer
230 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
231 address is ever taken. */
233 static inline bool
234 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
235 struct bfd_link_info *info)
237 return _bfd_elf_dynamic_symbol_p (h, info, 0);
240 /* Create an entry in a Alpha ELF linker hash table. */
242 static struct bfd_hash_entry *
243 elf64_alpha_link_hash_newfunc (struct bfd_hash_entry *entry,
244 struct bfd_hash_table *table,
245 const char *string)
247 struct alpha_elf_link_hash_entry *ret =
248 (struct alpha_elf_link_hash_entry *) entry;
250 /* Allocate the structure if it has not already been allocated by a
251 subclass. */
252 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
253 ret = ((struct alpha_elf_link_hash_entry *)
254 bfd_hash_allocate (table,
255 sizeof (struct alpha_elf_link_hash_entry)));
256 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
257 return (struct bfd_hash_entry *) ret;
259 /* Call the allocation method of the superclass. */
260 ret = ((struct alpha_elf_link_hash_entry *)
261 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
262 table, string));
263 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
265 /* Set local fields. */
266 memset (&ret->esym, 0, sizeof (EXTR));
267 /* We use -2 as a marker to indicate that the information has
268 not been set. -1 means there is no associated ifd. */
269 ret->esym.ifd = -2;
270 ret->flags = 0;
271 ret->got_entries = NULL;
272 ret->reloc_entries = NULL;
275 return (struct bfd_hash_entry *) ret;
278 /* Create a Alpha ELF linker hash table. */
280 static struct bfd_link_hash_table *
281 elf64_alpha_bfd_link_hash_table_create (bfd *abfd)
283 struct alpha_elf_link_hash_table *ret;
284 size_t amt = sizeof (struct alpha_elf_link_hash_table);
286 ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
287 if (ret == (struct alpha_elf_link_hash_table *) NULL)
288 return NULL;
290 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
291 elf64_alpha_link_hash_newfunc,
292 sizeof (struct alpha_elf_link_hash_entry),
293 ALPHA_ELF_DATA))
295 free (ret);
296 return NULL;
299 return &ret->root.root;
302 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
303 routine in order to handle the ECOFF debugging information. */
305 struct alpha_elf_find_line
307 struct ecoff_debug_info d;
308 struct ecoff_find_line i;
311 /* We have some private fields hanging off of the elf_tdata structure. */
313 struct alpha_elf_obj_tdata
315 struct elf_obj_tdata root;
317 /* For every input file, these are the got entries for that object's
318 local symbols. */
319 struct alpha_elf_got_entry ** local_got_entries;
321 /* For every input file, this is the object that owns the got that
322 this input file uses. */
323 bfd *gotobj;
325 /* For every got, this is a linked list through the objects using this got */
326 bfd *in_got_link_next;
328 /* For every got, this is a link to the next got subsegment. */
329 bfd *got_link_next;
331 /* For every got, this is the section. */
332 asection *got;
334 /* For every got, this is it's total number of words. */
335 int total_got_size;
337 /* For every got, this is the sum of the number of words required
338 to hold all of the member object's local got. */
339 int local_got_size;
341 /* Used by elf64_alpha_find_nearest_line entry point. */
342 struct alpha_elf_find_line *find_line_info;
346 #define alpha_elf_tdata(abfd) \
347 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
349 #define is_alpha_elf(bfd) \
350 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
351 && elf_tdata (bfd) != NULL \
352 && elf_object_id (bfd) == ALPHA_ELF_DATA)
354 static bool
355 elf64_alpha_mkobject (bfd *abfd)
357 return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
358 ALPHA_ELF_DATA);
361 static bool
362 elf64_alpha_object_p (bfd *abfd)
364 /* Set the right machine number for an Alpha ELF file. */
365 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
368 /* A relocation function which doesn't do anything. */
370 static bfd_reloc_status_type
371 elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
372 asymbol *sym ATTRIBUTE_UNUSED,
373 void * data ATTRIBUTE_UNUSED, asection *sec,
374 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
376 if (output_bfd)
377 reloc->address += sec->output_offset;
378 return bfd_reloc_ok;
381 /* A relocation function used for an unsupported reloc. */
383 static bfd_reloc_status_type
384 elf64_alpha_reloc_bad (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
385 asymbol *sym ATTRIBUTE_UNUSED,
386 void * data ATTRIBUTE_UNUSED, asection *sec,
387 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
389 if (output_bfd)
390 reloc->address += sec->output_offset;
391 return bfd_reloc_notsupported;
394 /* Do the work of the GPDISP relocation. */
396 static bfd_reloc_status_type
397 elf64_alpha_do_reloc_gpdisp (bfd *abfd, bfd_vma gpdisp, bfd_byte *p_ldah,
398 bfd_byte *p_lda)
400 bfd_reloc_status_type ret = bfd_reloc_ok;
401 bfd_vma addend;
402 unsigned long i_ldah, i_lda;
404 i_ldah = bfd_get_32 (abfd, p_ldah);
405 i_lda = bfd_get_32 (abfd, p_lda);
407 /* Complain if the instructions are not correct. */
408 if (((i_ldah >> 26) & 0x3f) != 0x09
409 || ((i_lda >> 26) & 0x3f) != 0x08)
410 ret = bfd_reloc_dangerous;
412 /* Extract the user-supplied offset, mirroring the sign extensions
413 that the instructions perform. */
414 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
415 addend = (addend ^ 0x80008000) - 0x80008000;
417 gpdisp += addend;
419 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
420 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
421 ret = bfd_reloc_overflow;
423 /* compensate for the sign extension again. */
424 i_ldah = ((i_ldah & 0xffff0000)
425 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
426 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
428 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
429 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
431 return ret;
434 /* The special function for the GPDISP reloc. */
436 static bfd_reloc_status_type
437 elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry,
438 asymbol *sym ATTRIBUTE_UNUSED, void * data,
439 asection *input_section, bfd *output_bfd,
440 char **err_msg)
442 bfd_reloc_status_type ret;
443 bfd_vma gp, relocation;
444 bfd_vma high_address;
445 bfd_byte *p_ldah, *p_lda;
447 /* Don't do anything if we're not doing a final link. */
448 if (output_bfd)
450 reloc_entry->address += input_section->output_offset;
451 return bfd_reloc_ok;
454 high_address = bfd_get_section_limit (abfd, input_section);
455 if (reloc_entry->address > high_address
456 || reloc_entry->address + reloc_entry->addend > high_address)
457 return bfd_reloc_outofrange;
459 /* The gp used in the portion of the output object to which this
460 input object belongs is cached on the input bfd. */
461 gp = _bfd_get_gp_value (abfd);
463 relocation = (input_section->output_section->vma
464 + input_section->output_offset
465 + reloc_entry->address);
467 p_ldah = (bfd_byte *) data + reloc_entry->address;
468 p_lda = p_ldah + reloc_entry->addend;
470 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
472 /* Complain if the instructions are not correct. */
473 if (ret == bfd_reloc_dangerous)
474 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
476 return ret;
479 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
480 from smaller values. Start with zero, widen, *then* decrement. */
481 #define MINUS_ONE (((bfd_vma)0) - 1)
484 #define SKIP_HOWTO(N) \
485 HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
487 static reloc_howto_type elf64_alpha_howto_table[] =
489 HOWTO (R_ALPHA_NONE, /* type */
490 0, /* rightshift */
491 0, /* size */
492 0, /* bitsize */
493 true, /* pc_relative */
494 0, /* bitpos */
495 complain_overflow_dont, /* complain_on_overflow */
496 elf64_alpha_reloc_nil, /* special_function */
497 "NONE", /* name */
498 false, /* partial_inplace */
499 0, /* src_mask */
500 0, /* dst_mask */
501 true), /* pcrel_offset */
503 /* A 32 bit reference to a symbol. */
504 HOWTO (R_ALPHA_REFLONG, /* type */
505 0, /* rightshift */
506 4, /* size */
507 32, /* bitsize */
508 false, /* pc_relative */
509 0, /* bitpos */
510 complain_overflow_bitfield, /* complain_on_overflow */
511 bfd_elf_generic_reloc, /* special_function */
512 "REFLONG", /* name */
513 false, /* partial_inplace */
514 0xffffffff, /* src_mask */
515 0xffffffff, /* dst_mask */
516 false), /* pcrel_offset */
518 /* A 64 bit reference to a symbol. */
519 HOWTO (R_ALPHA_REFQUAD, /* type */
520 0, /* rightshift */
521 8, /* size */
522 64, /* bitsize */
523 false, /* pc_relative */
524 0, /* bitpos */
525 complain_overflow_bitfield, /* complain_on_overflow */
526 bfd_elf_generic_reloc, /* special_function */
527 "REFQUAD", /* name */
528 false, /* partial_inplace */
529 MINUS_ONE, /* src_mask */
530 MINUS_ONE, /* dst_mask */
531 false), /* pcrel_offset */
533 /* A 32 bit GP relative offset. This is just like REFLONG except
534 that when the value is used the value of the gp register will be
535 added in. */
536 HOWTO (R_ALPHA_GPREL32, /* type */
537 0, /* rightshift */
538 4, /* size */
539 32, /* bitsize */
540 false, /* pc_relative */
541 0, /* bitpos */
542 complain_overflow_bitfield, /* complain_on_overflow */
543 bfd_elf_generic_reloc, /* special_function */
544 "GPREL32", /* name */
545 false, /* partial_inplace */
546 0xffffffff, /* src_mask */
547 0xffffffff, /* dst_mask */
548 false), /* pcrel_offset */
550 /* Used for an instruction that refers to memory off the GP register. */
551 HOWTO (R_ALPHA_LITERAL, /* type */
552 0, /* rightshift */
553 2, /* size */
554 16, /* bitsize */
555 false, /* pc_relative */
556 0, /* bitpos */
557 complain_overflow_signed, /* complain_on_overflow */
558 bfd_elf_generic_reloc, /* special_function */
559 "ELF_LITERAL", /* name */
560 false, /* partial_inplace */
561 0xffff, /* src_mask */
562 0xffff, /* dst_mask */
563 false), /* pcrel_offset */
565 /* This reloc only appears immediately following an ELF_LITERAL reloc.
566 It identifies a use of the literal. The symbol index is special:
567 1 means the literal address is in the base register of a memory
568 format instruction; 2 means the literal address is in the byte
569 offset register of a byte-manipulation instruction; 3 means the
570 literal address is in the target register of a jsr instruction.
571 This does not actually do any relocation. */
572 HOWTO (R_ALPHA_LITUSE, /* type */
573 0, /* rightshift */
574 2, /* size */
575 32, /* bitsize */
576 false, /* pc_relative */
577 0, /* bitpos */
578 complain_overflow_dont, /* complain_on_overflow */
579 elf64_alpha_reloc_nil, /* special_function */
580 "LITUSE", /* name */
581 false, /* partial_inplace */
582 0, /* src_mask */
583 0, /* dst_mask */
584 false), /* pcrel_offset */
586 /* Load the gp register. This is always used for a ldah instruction
587 which loads the upper 16 bits of the gp register. The symbol
588 index of the GPDISP instruction is an offset in bytes to the lda
589 instruction that loads the lower 16 bits. The value to use for
590 the relocation is the difference between the GP value and the
591 current location; the load will always be done against a register
592 holding the current address.
594 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
595 any offset is present in the instructions, it is an offset from
596 the register to the ldah instruction. This lets us avoid any
597 stupid hackery like inventing a gp value to do partial relocation
598 against. Also unlike ECOFF, we do the whole relocation off of
599 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
600 space consuming bit, that, since all the information was present
601 in the GPDISP_HI16 reloc. */
602 HOWTO (R_ALPHA_GPDISP, /* type */
603 16, /* rightshift */
604 4, /* size */
605 16, /* bitsize */
606 false, /* pc_relative */
607 0, /* bitpos */
608 complain_overflow_dont, /* complain_on_overflow */
609 elf64_alpha_reloc_gpdisp, /* special_function */
610 "GPDISP", /* name */
611 false, /* partial_inplace */
612 0xffff, /* src_mask */
613 0xffff, /* dst_mask */
614 true), /* pcrel_offset */
616 /* A 21 bit branch. */
617 HOWTO (R_ALPHA_BRADDR, /* type */
618 2, /* rightshift */
619 4, /* size */
620 21, /* bitsize */
621 true, /* pc_relative */
622 0, /* bitpos */
623 complain_overflow_signed, /* complain_on_overflow */
624 bfd_elf_generic_reloc, /* special_function */
625 "BRADDR", /* name */
626 false, /* partial_inplace */
627 0x1fffff, /* src_mask */
628 0x1fffff, /* dst_mask */
629 true), /* pcrel_offset */
631 /* A hint for a jump to a register. */
632 HOWTO (R_ALPHA_HINT, /* type */
633 2, /* rightshift */
634 2, /* size */
635 14, /* bitsize */
636 true, /* pc_relative */
637 0, /* bitpos */
638 complain_overflow_dont, /* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "HINT", /* name */
641 false, /* partial_inplace */
642 0x3fff, /* src_mask */
643 0x3fff, /* dst_mask */
644 true), /* pcrel_offset */
646 /* 16 bit PC relative offset. */
647 HOWTO (R_ALPHA_SREL16, /* type */
648 0, /* rightshift */
649 2, /* size */
650 16, /* bitsize */
651 true, /* pc_relative */
652 0, /* bitpos */
653 complain_overflow_signed, /* complain_on_overflow */
654 bfd_elf_generic_reloc, /* special_function */
655 "SREL16", /* name */
656 false, /* partial_inplace */
657 0xffff, /* src_mask */
658 0xffff, /* dst_mask */
659 true), /* pcrel_offset */
661 /* 32 bit PC relative offset. */
662 HOWTO (R_ALPHA_SREL32, /* type */
663 0, /* rightshift */
664 4, /* size */
665 32, /* bitsize */
666 true, /* pc_relative */
667 0, /* bitpos */
668 complain_overflow_signed, /* complain_on_overflow */
669 bfd_elf_generic_reloc, /* special_function */
670 "SREL32", /* name */
671 false, /* partial_inplace */
672 0xffffffff, /* src_mask */
673 0xffffffff, /* dst_mask */
674 true), /* pcrel_offset */
676 /* A 64 bit PC relative offset. */
677 HOWTO (R_ALPHA_SREL64, /* type */
678 0, /* rightshift */
679 8, /* size */
680 64, /* bitsize */
681 true, /* pc_relative */
682 0, /* bitpos */
683 complain_overflow_signed, /* complain_on_overflow */
684 bfd_elf_generic_reloc, /* special_function */
685 "SREL64", /* name */
686 false, /* partial_inplace */
687 MINUS_ONE, /* src_mask */
688 MINUS_ONE, /* dst_mask */
689 true), /* pcrel_offset */
691 /* Skip 12 - 16; deprecated ECOFF relocs. */
692 SKIP_HOWTO (12),
693 SKIP_HOWTO (13),
694 SKIP_HOWTO (14),
695 SKIP_HOWTO (15),
696 SKIP_HOWTO (16),
698 /* The high 16 bits of the displacement from GP to the target. */
699 HOWTO (R_ALPHA_GPRELHIGH,
700 0, /* rightshift */
701 2, /* size */
702 16, /* bitsize */
703 false, /* pc_relative */
704 0, /* bitpos */
705 complain_overflow_signed, /* complain_on_overflow */
706 bfd_elf_generic_reloc, /* special_function */
707 "GPRELHIGH", /* name */
708 false, /* partial_inplace */
709 0xffff, /* src_mask */
710 0xffff, /* dst_mask */
711 false), /* pcrel_offset */
713 /* The low 16 bits of the displacement from GP to the target. */
714 HOWTO (R_ALPHA_GPRELLOW,
715 0, /* rightshift */
716 2, /* size */
717 16, /* bitsize */
718 false, /* pc_relative */
719 0, /* bitpos */
720 complain_overflow_dont, /* complain_on_overflow */
721 bfd_elf_generic_reloc, /* special_function */
722 "GPRELLOW", /* name */
723 false, /* partial_inplace */
724 0xffff, /* src_mask */
725 0xffff, /* dst_mask */
726 false), /* pcrel_offset */
728 /* A 16-bit displacement from the GP to the target. */
729 HOWTO (R_ALPHA_GPREL16,
730 0, /* rightshift */
731 2, /* size */
732 16, /* bitsize */
733 false, /* pc_relative */
734 0, /* bitpos */
735 complain_overflow_signed, /* complain_on_overflow */
736 bfd_elf_generic_reloc, /* special_function */
737 "GPREL16", /* name */
738 false, /* partial_inplace */
739 0xffff, /* src_mask */
740 0xffff, /* dst_mask */
741 false), /* pcrel_offset */
743 /* Skip 20 - 23; deprecated ECOFF relocs. */
744 SKIP_HOWTO (20),
745 SKIP_HOWTO (21),
746 SKIP_HOWTO (22),
747 SKIP_HOWTO (23),
749 /* Misc ELF relocations. */
751 /* A dynamic relocation to copy the target into our .dynbss section. */
752 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
753 is present because every other ELF has one, but should not be used
754 because .dynbss is an ugly thing. */
755 HOWTO (R_ALPHA_COPY,
759 false,
761 complain_overflow_dont,
762 bfd_elf_generic_reloc,
763 "COPY",
764 false,
767 true),
769 /* A dynamic relocation for a .got entry. */
770 HOWTO (R_ALPHA_GLOB_DAT,
774 false,
776 complain_overflow_dont,
777 bfd_elf_generic_reloc,
778 "GLOB_DAT",
779 false,
782 true),
784 /* A dynamic relocation for a .plt entry. */
785 HOWTO (R_ALPHA_JMP_SLOT,
789 false,
791 complain_overflow_dont,
792 bfd_elf_generic_reloc,
793 "JMP_SLOT",
794 false,
797 true),
799 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
800 HOWTO (R_ALPHA_RELATIVE,
804 false,
806 complain_overflow_dont,
807 bfd_elf_generic_reloc,
808 "RELATIVE",
809 false,
812 true),
814 /* A 21 bit branch that adjusts for gp loads. */
815 HOWTO (R_ALPHA_BRSGP, /* type */
816 2, /* rightshift */
817 4, /* size */
818 21, /* bitsize */
819 true, /* pc_relative */
820 0, /* bitpos */
821 complain_overflow_signed, /* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
823 "BRSGP", /* name */
824 false, /* partial_inplace */
825 0x1fffff, /* src_mask */
826 0x1fffff, /* dst_mask */
827 true), /* pcrel_offset */
829 /* Creates a tls_index for the symbol in the got. */
830 HOWTO (R_ALPHA_TLSGD, /* type */
831 0, /* rightshift */
832 2, /* size */
833 16, /* bitsize */
834 false, /* pc_relative */
835 0, /* bitpos */
836 complain_overflow_signed, /* complain_on_overflow */
837 bfd_elf_generic_reloc, /* special_function */
838 "TLSGD", /* name */
839 false, /* partial_inplace */
840 0xffff, /* src_mask */
841 0xffff, /* dst_mask */
842 false), /* pcrel_offset */
844 /* Creates a tls_index for the (current) module in the got. */
845 HOWTO (R_ALPHA_TLSLDM, /* type */
846 0, /* rightshift */
847 2, /* size */
848 16, /* bitsize */
849 false, /* pc_relative */
850 0, /* bitpos */
851 complain_overflow_signed, /* complain_on_overflow */
852 bfd_elf_generic_reloc, /* special_function */
853 "TLSLDM", /* name */
854 false, /* partial_inplace */
855 0xffff, /* src_mask */
856 0xffff, /* dst_mask */
857 false), /* pcrel_offset */
859 /* A dynamic relocation for a DTP module entry. */
860 HOWTO (R_ALPHA_DTPMOD64, /* type */
861 0, /* rightshift */
862 8, /* size */
863 64, /* bitsize */
864 false, /* pc_relative */
865 0, /* bitpos */
866 complain_overflow_bitfield, /* complain_on_overflow */
867 bfd_elf_generic_reloc, /* special_function */
868 "DTPMOD64", /* name */
869 false, /* partial_inplace */
870 MINUS_ONE, /* src_mask */
871 MINUS_ONE, /* dst_mask */
872 false), /* pcrel_offset */
874 /* Creates a 64-bit offset in the got for the displacement
875 from DTP to the target. */
876 HOWTO (R_ALPHA_GOTDTPREL, /* type */
877 0, /* rightshift */
878 2, /* size */
879 16, /* bitsize */
880 false, /* pc_relative */
881 0, /* bitpos */
882 complain_overflow_signed, /* complain_on_overflow */
883 bfd_elf_generic_reloc, /* special_function */
884 "GOTDTPREL", /* name */
885 false, /* partial_inplace */
886 0xffff, /* src_mask */
887 0xffff, /* dst_mask */
888 false), /* pcrel_offset */
890 /* A dynamic relocation for a displacement from DTP to the target. */
891 HOWTO (R_ALPHA_DTPREL64, /* type */
892 0, /* rightshift */
893 8, /* size */
894 64, /* bitsize */
895 false, /* pc_relative */
896 0, /* bitpos */
897 complain_overflow_bitfield, /* complain_on_overflow */
898 bfd_elf_generic_reloc, /* special_function */
899 "DTPREL64", /* name */
900 false, /* partial_inplace */
901 MINUS_ONE, /* src_mask */
902 MINUS_ONE, /* dst_mask */
903 false), /* pcrel_offset */
905 /* The high 16 bits of the displacement from DTP to the target. */
906 HOWTO (R_ALPHA_DTPRELHI, /* type */
907 0, /* rightshift */
908 2, /* size */
909 16, /* bitsize */
910 false, /* pc_relative */
911 0, /* bitpos */
912 complain_overflow_signed, /* complain_on_overflow */
913 bfd_elf_generic_reloc, /* special_function */
914 "DTPRELHI", /* name */
915 false, /* partial_inplace */
916 0xffff, /* src_mask */
917 0xffff, /* dst_mask */
918 false), /* pcrel_offset */
920 /* The low 16 bits of the displacement from DTP to the target. */
921 HOWTO (R_ALPHA_DTPRELLO, /* type */
922 0, /* rightshift */
923 2, /* size */
924 16, /* bitsize */
925 false, /* pc_relative */
926 0, /* bitpos */
927 complain_overflow_dont, /* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "DTPRELLO", /* name */
930 false, /* partial_inplace */
931 0xffff, /* src_mask */
932 0xffff, /* dst_mask */
933 false), /* pcrel_offset */
935 /* A 16-bit displacement from DTP to the target. */
936 HOWTO (R_ALPHA_DTPREL16, /* type */
937 0, /* rightshift */
938 2, /* size */
939 16, /* bitsize */
940 false, /* pc_relative */
941 0, /* bitpos */
942 complain_overflow_signed, /* complain_on_overflow */
943 bfd_elf_generic_reloc, /* special_function */
944 "DTPREL16", /* name */
945 false, /* partial_inplace */
946 0xffff, /* src_mask */
947 0xffff, /* dst_mask */
948 false), /* pcrel_offset */
950 /* Creates a 64-bit offset in the got for the displacement
951 from TP to the target. */
952 HOWTO (R_ALPHA_GOTTPREL, /* type */
953 0, /* rightshift */
954 2, /* size */
955 16, /* bitsize */
956 false, /* pc_relative */
957 0, /* bitpos */
958 complain_overflow_signed, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* special_function */
960 "GOTTPREL", /* name */
961 false, /* partial_inplace */
962 0xffff, /* src_mask */
963 0xffff, /* dst_mask */
964 false), /* pcrel_offset */
966 /* A dynamic relocation for a displacement from TP to the target. */
967 HOWTO (R_ALPHA_TPREL64, /* type */
968 0, /* rightshift */
969 8, /* size */
970 64, /* bitsize */
971 false, /* pc_relative */
972 0, /* bitpos */
973 complain_overflow_bitfield, /* complain_on_overflow */
974 bfd_elf_generic_reloc, /* special_function */
975 "TPREL64", /* name */
976 false, /* partial_inplace */
977 MINUS_ONE, /* src_mask */
978 MINUS_ONE, /* dst_mask */
979 false), /* pcrel_offset */
981 /* The high 16 bits of the displacement from TP to the target. */
982 HOWTO (R_ALPHA_TPRELHI, /* type */
983 0, /* rightshift */
984 2, /* size */
985 16, /* bitsize */
986 false, /* pc_relative */
987 0, /* bitpos */
988 complain_overflow_signed, /* complain_on_overflow */
989 bfd_elf_generic_reloc, /* special_function */
990 "TPRELHI", /* name */
991 false, /* partial_inplace */
992 0xffff, /* src_mask */
993 0xffff, /* dst_mask */
994 false), /* pcrel_offset */
996 /* The low 16 bits of the displacement from TP to the target. */
997 HOWTO (R_ALPHA_TPRELLO, /* type */
998 0, /* rightshift */
999 2, /* size */
1000 16, /* bitsize */
1001 false, /* pc_relative */
1002 0, /* bitpos */
1003 complain_overflow_dont, /* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "TPRELLO", /* name */
1006 false, /* partial_inplace */
1007 0xffff, /* src_mask */
1008 0xffff, /* dst_mask */
1009 false), /* pcrel_offset */
1011 /* A 16-bit displacement from TP to the target. */
1012 HOWTO (R_ALPHA_TPREL16, /* type */
1013 0, /* rightshift */
1014 2, /* size */
1015 16, /* bitsize */
1016 false, /* pc_relative */
1017 0, /* bitpos */
1018 complain_overflow_signed, /* complain_on_overflow */
1019 bfd_elf_generic_reloc, /* special_function */
1020 "TPREL16", /* name */
1021 false, /* partial_inplace */
1022 0xffff, /* src_mask */
1023 0xffff, /* dst_mask */
1024 false), /* pcrel_offset */
1027 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1029 struct elf_reloc_map
1031 bfd_reloc_code_real_type bfd_reloc_val;
1032 int elf_reloc_val;
1035 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1037 {BFD_RELOC_NONE, R_ALPHA_NONE},
1038 {BFD_RELOC_32, R_ALPHA_REFLONG},
1039 {BFD_RELOC_64, R_ALPHA_REFQUAD},
1040 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
1041 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
1042 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
1043 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
1044 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
1045 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
1046 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
1047 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
1048 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
1049 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
1050 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
1051 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
1052 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
1053 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
1054 {BFD_RELOC_ALPHA_TLSGD, R_ALPHA_TLSGD},
1055 {BFD_RELOC_ALPHA_TLSLDM, R_ALPHA_TLSLDM},
1056 {BFD_RELOC_ALPHA_DTPMOD64, R_ALPHA_DTPMOD64},
1057 {BFD_RELOC_ALPHA_GOTDTPREL16, R_ALPHA_GOTDTPREL},
1058 {BFD_RELOC_ALPHA_DTPREL64, R_ALPHA_DTPREL64},
1059 {BFD_RELOC_ALPHA_DTPREL_HI16, R_ALPHA_DTPRELHI},
1060 {BFD_RELOC_ALPHA_DTPREL_LO16, R_ALPHA_DTPRELLO},
1061 {BFD_RELOC_ALPHA_DTPREL16, R_ALPHA_DTPREL16},
1062 {BFD_RELOC_ALPHA_GOTTPREL16, R_ALPHA_GOTTPREL},
1063 {BFD_RELOC_ALPHA_TPREL64, R_ALPHA_TPREL64},
1064 {BFD_RELOC_ALPHA_TPREL_HI16, R_ALPHA_TPRELHI},
1065 {BFD_RELOC_ALPHA_TPREL_LO16, R_ALPHA_TPRELLO},
1066 {BFD_RELOC_ALPHA_TPREL16, R_ALPHA_TPREL16},
1069 /* Given a BFD reloc type, return a HOWTO structure. */
1071 static reloc_howto_type *
1072 elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1073 bfd_reloc_code_real_type code)
1075 const struct elf_reloc_map *i, *e;
1076 i = e = elf64_alpha_reloc_map;
1077 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1078 for (; i != e; ++i)
1080 if (i->bfd_reloc_val == code)
1081 return &elf64_alpha_howto_table[i->elf_reloc_val];
1083 return 0;
1086 static reloc_howto_type *
1087 elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1088 const char *r_name)
1090 unsigned int i;
1092 for (i = 0;
1093 i < (sizeof (elf64_alpha_howto_table)
1094 / sizeof (elf64_alpha_howto_table[0]));
1095 i++)
1096 if (elf64_alpha_howto_table[i].name != NULL
1097 && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0)
1098 return &elf64_alpha_howto_table[i];
1100 return NULL;
1103 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1105 static bool
1106 elf64_alpha_info_to_howto (bfd *abfd, arelent *cache_ptr,
1107 Elf_Internal_Rela *dst)
1109 unsigned r_type = ELF64_R_TYPE(dst->r_info);
1111 if (r_type >= R_ALPHA_max)
1113 /* xgettext:c-format */
1114 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1115 abfd, r_type);
1116 bfd_set_error (bfd_error_bad_value);
1117 return false;
1119 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1120 return true;
1123 /* These two relocations create a two-word entry in the got. */
1124 #define alpha_got_entry_size(r_type) \
1125 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1127 /* This is PT_TLS segment p_vaddr. */
1128 #define alpha_get_dtprel_base(info) \
1129 (elf_hash_table (info)->tls_sec->vma)
1131 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1132 is assigned offset round(16, PT_TLS p_align). */
1133 #define alpha_get_tprel_base(info) \
1134 (elf_hash_table (info)->tls_sec->vma \
1135 - align_power ((bfd_vma) 16, \
1136 elf_hash_table (info)->tls_sec->alignment_power))
1138 /* Handle an Alpha specific section when reading an object file. This
1139 is called when bfd_section_from_shdr finds a section with an unknown
1140 type. */
1142 static bool
1143 elf64_alpha_section_from_shdr (bfd *abfd,
1144 Elf_Internal_Shdr *hdr,
1145 const char *name,
1146 int shindex)
1148 asection *newsect;
1150 /* There ought to be a place to keep ELF backend specific flags, but
1151 at the moment there isn't one. We just keep track of the
1152 sections by their name, instead. Fortunately, the ABI gives
1153 suggested names for all the MIPS specific sections, so we will
1154 probably get away with this. */
1155 switch (hdr->sh_type)
1157 case SHT_ALPHA_DEBUG:
1158 if (strcmp (name, ".mdebug") != 0)
1159 return false;
1160 break;
1161 default:
1162 return false;
1165 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1166 return false;
1167 newsect = hdr->bfd_section;
1169 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1171 if (!bfd_set_section_flags (newsect,
1172 bfd_section_flags (newsect) | SEC_DEBUGGING))
1173 return false;
1176 return true;
1179 /* Convert Alpha specific section flags to bfd internal section flags. */
1181 static bool
1182 elf64_alpha_section_flags (const Elf_Internal_Shdr *hdr)
1184 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1185 hdr->bfd_section->flags |= SEC_SMALL_DATA;
1187 return true;
1190 /* Set the correct type for an Alpha ELF section. We do this by the
1191 section name, which is a hack, but ought to work. */
1193 static bool
1194 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1196 register const char *name;
1198 name = bfd_section_name (sec);
1200 if (strcmp (name, ".mdebug") == 0)
1202 hdr->sh_type = SHT_ALPHA_DEBUG;
1203 /* In a shared object on Irix 5.3, the .mdebug section has an
1204 entsize of 0. FIXME: Does this matter? */
1205 if ((abfd->flags & DYNAMIC) != 0 )
1206 hdr->sh_entsize = 0;
1207 else
1208 hdr->sh_entsize = 1;
1210 else if ((sec->flags & SEC_SMALL_DATA)
1211 || strcmp (name, ".sdata") == 0
1212 || strcmp (name, ".sbss") == 0
1213 || strcmp (name, ".lit4") == 0
1214 || strcmp (name, ".lit8") == 0)
1215 hdr->sh_flags |= SHF_ALPHA_GPREL;
1217 return true;
1220 /* Hook called by the linker routine which adds symbols from an object
1221 file. We use it to put .comm items in .sbss, and not .bss. */
1223 static bool
1224 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1225 Elf_Internal_Sym *sym,
1226 const char **namep ATTRIBUTE_UNUSED,
1227 flagword *flagsp ATTRIBUTE_UNUSED,
1228 asection **secp, bfd_vma *valp)
1230 if (sym->st_shndx == SHN_COMMON
1231 && !bfd_link_relocatable (info)
1232 && sym->st_size <= elf_gp_size (abfd))
1234 /* Common symbols less than or equal to -G nn bytes are
1235 automatically put into .sbss. */
1237 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1239 if (scomm == NULL)
1241 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1242 (SEC_ALLOC
1243 | SEC_IS_COMMON
1244 | SEC_SMALL_DATA
1245 | SEC_LINKER_CREATED));
1246 if (scomm == NULL)
1247 return false;
1250 *secp = scomm;
1251 *valp = sym->st_size;
1254 return true;
1257 /* Create the .got section. */
1259 static bool
1260 elf64_alpha_create_got_section (bfd *abfd,
1261 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1263 flagword flags;
1264 asection *s;
1266 if (! is_alpha_elf (abfd))
1267 return false;
1269 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1270 | SEC_LINKER_CREATED);
1271 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1272 if (s == NULL
1273 || !bfd_set_section_alignment (s, 3))
1274 return false;
1276 alpha_elf_tdata (abfd)->got = s;
1278 /* Make sure the object's gotobj is set to itself so that we default
1279 to every object with its own .got. We'll merge .gots later once
1280 we've collected each object's info. */
1281 alpha_elf_tdata (abfd)->gotobj = abfd;
1283 return true;
1286 /* Create all the dynamic sections. */
1288 static bool
1289 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1291 asection *s;
1292 flagword flags;
1293 struct elf_link_hash_entry *h;
1295 if (! is_alpha_elf (abfd))
1296 return false;
1298 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1300 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1301 | SEC_LINKER_CREATED
1302 | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1303 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1304 elf_hash_table (info)->splt = s;
1305 if (s == NULL || ! bfd_set_section_alignment (s, 4))
1306 return false;
1308 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1309 .plt section. */
1310 h = _bfd_elf_define_linkage_sym (abfd, info, s,
1311 "_PROCEDURE_LINKAGE_TABLE_");
1312 elf_hash_table (info)->hplt = h;
1313 if (h == NULL)
1314 return false;
1316 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1317 | SEC_LINKER_CREATED | SEC_READONLY);
1318 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1319 elf_hash_table (info)->srelplt = s;
1320 if (s == NULL || ! bfd_set_section_alignment (s, 3))
1321 return false;
1323 if (elf64_alpha_use_secureplt)
1325 flags = SEC_ALLOC | SEC_LINKER_CREATED;
1326 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1327 elf_hash_table (info)->sgotplt = s;
1328 if (s == NULL || ! bfd_set_section_alignment (s, 3))
1329 return false;
1332 /* We may or may not have created a .got section for this object, but
1333 we definitely havn't done the rest of the work. */
1335 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1337 if (!elf64_alpha_create_got_section (abfd, info))
1338 return false;
1341 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1342 | SEC_LINKER_CREATED | SEC_READONLY);
1343 s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1344 elf_hash_table (info)->srelgot = s;
1345 if (s == NULL
1346 || !bfd_set_section_alignment (s, 3))
1347 return false;
1349 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1350 dynobj's .got section. We don't do this in the linker script
1351 because we don't want to define the symbol if we are not creating
1352 a global offset table. */
1353 h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1354 "_GLOBAL_OFFSET_TABLE_");
1355 elf_hash_table (info)->hgot = h;
1356 if (h == NULL)
1357 return false;
1359 return true;
1362 /* Read ECOFF debugging information from a .mdebug section into a
1363 ecoff_debug_info structure. */
1365 static bool
1366 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1367 struct ecoff_debug_info *debug)
1369 HDRR *symhdr;
1370 const struct ecoff_debug_swap *swap;
1371 char *ext_hdr = NULL;
1373 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1374 memset (debug, 0, sizeof (*debug));
1376 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1377 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1378 goto error_return;
1380 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1381 swap->external_hdr_size))
1382 goto error_return;
1384 symhdr = &debug->symbolic_header;
1385 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1387 /* The symbolic header contains absolute file offsets and sizes to
1388 read. */
1389 #define READ(ptr, offset, count, size, type) \
1390 do \
1392 size_t amt; \
1393 debug->ptr = NULL; \
1394 if (symhdr->count == 0) \
1395 break; \
1396 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
1398 bfd_set_error (bfd_error_file_too_big); \
1399 goto error_return; \
1401 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0) \
1402 goto error_return; \
1403 debug->ptr = (type) _bfd_malloc_and_read (abfd, amt, amt); \
1404 if (debug->ptr == NULL) \
1405 goto error_return; \
1406 } while (0)
1408 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1409 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1410 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1411 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1412 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1413 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1414 union aux_ext *);
1415 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1416 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1417 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1418 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1419 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1420 #undef READ
1422 debug->fdr = NULL;
1424 return true;
1426 error_return:
1427 free (ext_hdr);
1428 _bfd_ecoff_free_ecoff_debug_info (debug);
1429 return false;
1432 /* Alpha ELF local labels start with '$'. */
1434 static bool
1435 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1437 return name[0] == '$';
1440 static bool
1441 elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
1442 asection *section, bfd_vma offset,
1443 const char **filename_ptr,
1444 const char **functionname_ptr,
1445 unsigned int *line_ptr,
1446 unsigned int *discriminator_ptr)
1448 asection *msec;
1450 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
1451 filename_ptr, functionname_ptr,
1452 line_ptr, discriminator_ptr,
1453 dwarf_debug_sections,
1454 &elf_tdata (abfd)->dwarf2_find_line_info)
1455 == 1)
1456 return true;
1458 msec = bfd_get_section_by_name (abfd, ".mdebug");
1459 if (msec != NULL)
1461 flagword origflags;
1462 struct alpha_elf_find_line *fi;
1463 const struct ecoff_debug_swap * const swap =
1464 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1466 /* If we are called during a link, alpha_elf_final_link may have
1467 cleared the SEC_HAS_CONTENTS field. We force it back on here
1468 if appropriate (which it normally will be). */
1469 origflags = msec->flags;
1470 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1471 msec->flags |= SEC_HAS_CONTENTS;
1473 fi = alpha_elf_tdata (abfd)->find_line_info;
1474 if (fi == NULL)
1476 bfd_size_type external_fdr_size;
1477 char *fraw_src;
1478 char *fraw_end;
1479 struct fdr *fdr_ptr;
1480 bfd_size_type amt = sizeof (struct alpha_elf_find_line);
1482 fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt);
1483 if (fi == NULL)
1485 msec->flags = origflags;
1486 return false;
1489 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1491 msec->flags = origflags;
1492 return false;
1495 /* Swap in the FDR information. */
1496 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1497 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1498 if (fi->d.fdr == NULL)
1500 msec->flags = origflags;
1501 return false;
1503 external_fdr_size = swap->external_fdr_size;
1504 fdr_ptr = fi->d.fdr;
1505 fraw_src = (char *) fi->d.external_fdr;
1506 fraw_end = (fraw_src
1507 + fi->d.symbolic_header.ifdMax * external_fdr_size);
1508 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1509 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
1511 alpha_elf_tdata (abfd)->find_line_info = fi;
1514 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1515 &fi->i, filename_ptr, functionname_ptr,
1516 line_ptr))
1518 msec->flags = origflags;
1519 return true;
1522 msec->flags = origflags;
1525 /* Fall back on the generic ELF find_nearest_line routine. */
1527 return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
1528 filename_ptr, functionname_ptr,
1529 line_ptr, discriminator_ptr);
1532 /* Structure used to pass information to alpha_elf_output_extsym. */
1534 struct extsym_info
1536 bfd *abfd;
1537 struct bfd_link_info *info;
1538 struct ecoff_debug_info *debug;
1539 const struct ecoff_debug_swap *swap;
1540 bool failed;
1543 static bool
1544 elf64_alpha_output_extsym (struct elf_link_hash_entry *x, void * data)
1546 struct alpha_elf_link_hash_entry *h = (struct alpha_elf_link_hash_entry *) x;
1547 struct extsym_info *einfo = (struct extsym_info *) data;
1548 bool strip;
1549 asection *sec, *output_section;
1551 if (h->root.indx == -2)
1552 strip = false;
1553 else if ((h->root.def_dynamic
1554 || h->root.ref_dynamic
1555 || h->root.root.type == bfd_link_hash_new)
1556 && !h->root.def_regular
1557 && !h->root.ref_regular)
1558 strip = true;
1559 else if (einfo->info->strip == strip_all
1560 || (einfo->info->strip == strip_some
1561 && bfd_hash_lookup (einfo->info->keep_hash,
1562 h->root.root.root.string,
1563 false, false) == NULL))
1564 strip = true;
1565 else
1566 strip = false;
1568 if (strip)
1569 return true;
1571 if (h->esym.ifd == -2)
1573 h->esym.jmptbl = 0;
1574 h->esym.cobol_main = 0;
1575 h->esym.weakext = 0;
1576 h->esym.reserved = 0;
1577 h->esym.ifd = ifdNil;
1578 h->esym.asym.value = 0;
1579 h->esym.asym.st = stGlobal;
1581 if (h->root.root.type != bfd_link_hash_defined
1582 && h->root.root.type != bfd_link_hash_defweak)
1583 h->esym.asym.sc = scAbs;
1584 else
1586 const char *name;
1588 sec = h->root.root.u.def.section;
1589 output_section = sec->output_section;
1591 /* When making a shared library and symbol h is the one from
1592 the another shared library, OUTPUT_SECTION may be null. */
1593 if (output_section == NULL)
1594 h->esym.asym.sc = scUndefined;
1595 else
1597 name = bfd_section_name (output_section);
1599 if (strcmp (name, ".text") == 0)
1600 h->esym.asym.sc = scText;
1601 else if (strcmp (name, ".data") == 0)
1602 h->esym.asym.sc = scData;
1603 else if (strcmp (name, ".sdata") == 0)
1604 h->esym.asym.sc = scSData;
1605 else if (strcmp (name, ".rodata") == 0
1606 || strcmp (name, ".rdata") == 0)
1607 h->esym.asym.sc = scRData;
1608 else if (strcmp (name, ".bss") == 0)
1609 h->esym.asym.sc = scBss;
1610 else if (strcmp (name, ".sbss") == 0)
1611 h->esym.asym.sc = scSBss;
1612 else if (strcmp (name, ".init") == 0)
1613 h->esym.asym.sc = scInit;
1614 else if (strcmp (name, ".fini") == 0)
1615 h->esym.asym.sc = scFini;
1616 else
1617 h->esym.asym.sc = scAbs;
1621 h->esym.asym.reserved = 0;
1622 h->esym.asym.index = indexNil;
1625 if (h->root.root.type == bfd_link_hash_common)
1626 h->esym.asym.value = h->root.root.u.c.size;
1627 else if (h->root.root.type == bfd_link_hash_defined
1628 || h->root.root.type == bfd_link_hash_defweak)
1630 if (h->esym.asym.sc == scCommon)
1631 h->esym.asym.sc = scBss;
1632 else if (h->esym.asym.sc == scSCommon)
1633 h->esym.asym.sc = scSBss;
1635 sec = h->root.root.u.def.section;
1636 output_section = sec->output_section;
1637 if (output_section != NULL)
1638 h->esym.asym.value = (h->root.root.u.def.value
1639 + sec->output_offset
1640 + output_section->vma);
1641 else
1642 h->esym.asym.value = 0;
1645 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1646 h->root.root.root.string,
1647 &h->esym))
1649 einfo->failed = true;
1650 return false;
1653 return true;
1656 /* Search for and possibly create a got entry. */
1658 static struct alpha_elf_got_entry *
1659 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1660 unsigned long r_type, unsigned long r_symndx,
1661 bfd_vma r_addend)
1663 struct alpha_elf_got_entry *gotent;
1664 struct alpha_elf_got_entry **slot;
1666 if (h)
1667 slot = &h->got_entries;
1668 else
1670 /* This is a local .got entry -- record for merge. */
1672 struct alpha_elf_got_entry **local_got_entries;
1674 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1675 if (!local_got_entries)
1677 bfd_size_type size;
1678 Elf_Internal_Shdr *symtab_hdr;
1680 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1681 size = symtab_hdr->sh_info;
1682 size *= sizeof (struct alpha_elf_got_entry *);
1684 local_got_entries
1685 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1686 if (!local_got_entries)
1687 return NULL;
1689 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1692 slot = &local_got_entries[r_symndx];
1695 for (gotent = *slot; gotent ; gotent = gotent->next)
1696 if (gotent->gotobj == abfd
1697 && gotent->reloc_type == r_type
1698 && gotent->addend == r_addend)
1699 break;
1701 if (!gotent)
1703 int entry_size;
1704 size_t amt;
1706 amt = sizeof (struct alpha_elf_got_entry);
1707 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1708 if (!gotent)
1709 return NULL;
1711 gotent->gotobj = abfd;
1712 gotent->addend = r_addend;
1713 gotent->got_offset = -1;
1714 gotent->plt_offset = -1;
1715 gotent->use_count = 1;
1716 gotent->reloc_type = r_type;
1717 gotent->reloc_done = 0;
1718 gotent->reloc_xlated = 0;
1720 gotent->next = *slot;
1721 *slot = gotent;
1723 entry_size = alpha_got_entry_size (r_type);
1724 alpha_elf_tdata (abfd)->total_got_size += entry_size;
1725 if (!h)
1726 alpha_elf_tdata(abfd)->local_got_size += entry_size;
1728 else
1729 gotent->use_count += 1;
1731 return gotent;
1734 static bool
1735 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1737 return ((ah->root.type == STT_FUNC
1738 || ah->root.root.type == bfd_link_hash_undefweak
1739 || ah->root.root.type == bfd_link_hash_undefined)
1740 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1741 && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1744 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
1745 Don't do so for code sections. We want to keep ordering of LITERAL/LITUSE
1746 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
1747 relocs to be sorted. */
1749 static bool
1750 elf64_alpha_sort_relocs_p (asection *sec)
1752 return (sec->flags & SEC_CODE) == 0;
1756 /* Handle dynamic relocations when doing an Alpha ELF link. */
1758 static bool
1759 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1760 asection *sec, const Elf_Internal_Rela *relocs)
1762 bfd *dynobj;
1763 asection *sreloc;
1764 Elf_Internal_Shdr *symtab_hdr;
1765 struct alpha_elf_link_hash_entry **sym_hashes;
1766 const Elf_Internal_Rela *rel, *relend;
1768 if (bfd_link_relocatable (info))
1769 return true;
1771 BFD_ASSERT (is_alpha_elf (abfd));
1773 dynobj = elf_hash_table (info)->dynobj;
1774 if (dynobj == NULL)
1775 elf_hash_table (info)->dynobj = dynobj = abfd;
1777 sreloc = NULL;
1778 symtab_hdr = &elf_symtab_hdr (abfd);
1779 sym_hashes = alpha_elf_sym_hashes (abfd);
1781 relend = relocs + sec->reloc_count;
1782 for (rel = relocs; rel < relend; ++rel)
1784 enum {
1785 NEED_GOT = 1,
1786 NEED_GOT_ENTRY = 2,
1787 NEED_DYNREL = 4
1790 unsigned long r_symndx, r_type;
1791 struct alpha_elf_link_hash_entry *h;
1792 unsigned int gotent_flags;
1793 bool maybe_dynamic;
1794 unsigned int need;
1795 bfd_vma addend;
1797 r_symndx = ELF64_R_SYM (rel->r_info);
1798 if (r_symndx < symtab_hdr->sh_info)
1799 h = NULL;
1800 else
1802 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1804 while (h->root.root.type == bfd_link_hash_indirect
1805 || h->root.root.type == bfd_link_hash_warning)
1806 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1808 /* PR15323, ref flags aren't set for references in the same
1809 object. */
1810 h->root.ref_regular = 1;
1813 /* We can only get preliminary data on whether a symbol is
1814 locally or externally defined, as not all of the input files
1815 have yet been processed. Do something with what we know, as
1816 this may help reduce memory usage and processing time later. */
1817 maybe_dynamic = false;
1818 if (h && ((bfd_link_pic (info)
1819 && (!info->symbolic
1820 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1821 || !h->root.def_regular
1822 || h->root.root.type == bfd_link_hash_defweak))
1823 maybe_dynamic = true;
1825 need = 0;
1826 gotent_flags = 0;
1827 r_type = ELF64_R_TYPE (rel->r_info);
1828 addend = rel->r_addend;
1830 switch (r_type)
1832 case R_ALPHA_LITERAL:
1833 need = NEED_GOT | NEED_GOT_ENTRY;
1835 /* Remember how this literal is used from its LITUSEs.
1836 This will be important when it comes to decide if we can
1837 create a .plt entry for a function symbol. */
1838 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
1839 if (rel->r_addend >= 1 && rel->r_addend <= 6)
1840 gotent_flags |= 1 << rel->r_addend;
1841 --rel;
1843 /* No LITUSEs -- presumably the address is used somehow. */
1844 if (gotent_flags == 0)
1845 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
1846 break;
1848 case R_ALPHA_GPDISP:
1849 case R_ALPHA_GPREL16:
1850 case R_ALPHA_GPREL32:
1851 case R_ALPHA_GPRELHIGH:
1852 case R_ALPHA_GPRELLOW:
1853 case R_ALPHA_BRSGP:
1854 need = NEED_GOT;
1855 break;
1857 case R_ALPHA_REFLONG:
1858 case R_ALPHA_REFQUAD:
1859 if (bfd_link_pic (info) || maybe_dynamic)
1860 need = NEED_DYNREL;
1861 break;
1863 case R_ALPHA_TLSLDM:
1864 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1865 reloc to the STN_UNDEF (0) symbol so that they all match. */
1866 r_symndx = STN_UNDEF;
1867 h = 0;
1868 maybe_dynamic = false;
1869 /* FALLTHRU */
1871 case R_ALPHA_TLSGD:
1872 case R_ALPHA_GOTDTPREL:
1873 need = NEED_GOT | NEED_GOT_ENTRY;
1874 break;
1876 case R_ALPHA_GOTTPREL:
1877 need = NEED_GOT | NEED_GOT_ENTRY;
1878 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
1879 if (bfd_link_pic (info))
1880 info->flags |= DF_STATIC_TLS;
1881 break;
1883 case R_ALPHA_TPREL64:
1884 if (bfd_link_dll (info))
1886 info->flags |= DF_STATIC_TLS;
1887 need = NEED_DYNREL;
1889 else if (maybe_dynamic)
1890 need = NEED_DYNREL;
1891 break;
1894 if (need & NEED_GOT)
1896 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1898 if (!elf64_alpha_create_got_section (abfd, info))
1899 return false;
1903 if (need & NEED_GOT_ENTRY)
1905 struct alpha_elf_got_entry *gotent;
1907 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
1908 if (!gotent)
1909 return false;
1911 if (gotent_flags)
1913 gotent->flags |= gotent_flags;
1914 if (h)
1916 gotent_flags |= h->flags;
1917 h->flags = gotent_flags;
1919 /* Make a guess as to whether a .plt entry is needed. */
1920 /* ??? It appears that we won't make it into
1921 adjust_dynamic_symbol for symbols that remain
1922 totally undefined. Copying this check here means
1923 we can create a plt entry for them too. */
1924 h->root.needs_plt
1925 = (maybe_dynamic && elf64_alpha_want_plt (h));
1930 if (need & NEED_DYNREL)
1932 /* We need to create the section here now whether we eventually
1933 use it or not so that it gets mapped to an output section by
1934 the linker. If not used, we'll kill it in size_dynamic_sections. */
1935 if (sreloc == NULL)
1937 sreloc = _bfd_elf_make_dynamic_reloc_section
1938 (sec, dynobj, 3, abfd, /*rela?*/ true);
1940 if (sreloc == NULL)
1941 return false;
1944 if (h)
1946 /* Since we havn't seen all of the input symbols yet, we
1947 don't know whether we'll actually need a dynamic relocation
1948 entry for this reloc. So make a record of it. Once we
1949 find out if this thing needs dynamic relocation we'll
1950 expand the relocation sections by the appropriate amount. */
1952 struct alpha_elf_reloc_entry *rent;
1954 for (rent = h->reloc_entries; rent; rent = rent->next)
1955 if (rent->rtype == r_type && rent->srel == sreloc)
1956 break;
1958 if (!rent)
1960 size_t amt = sizeof (struct alpha_elf_reloc_entry);
1961 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
1962 if (!rent)
1963 return false;
1965 rent->srel = sreloc;
1966 rent->sec = sec;
1967 rent->rtype = r_type;
1968 rent->count = 1;
1970 rent->next = h->reloc_entries;
1971 h->reloc_entries = rent;
1973 else
1974 rent->count++;
1976 else if (bfd_link_pic (info))
1978 /* If this is a shared library, and the section is to be
1979 loaded into memory, we need a RELATIVE reloc. */
1980 sreloc->size += sizeof (Elf64_External_Rela);
1981 if (sec->flags & SEC_READONLY)
1983 info->flags |= DF_TEXTREL;
1984 info->callbacks->minfo
1985 (_("%pB: dynamic relocation against a local symbol in "
1986 "read-only section `%pA'\n"),
1987 sec->owner, sec);
1993 return true;
1996 /* Return the section that should be marked against GC for a given
1997 relocation. */
1999 static asection *
2000 elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info,
2001 Elf_Internal_Rela *rel,
2002 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
2004 /* These relocations don't really reference a symbol. Instead we store
2005 extra data in their addend slot. Ignore the symbol. */
2006 switch (ELF64_R_TYPE (rel->r_info))
2008 case R_ALPHA_LITUSE:
2009 case R_ALPHA_GPDISP:
2010 case R_ALPHA_HINT:
2011 return NULL;
2014 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2017 /* Adjust a symbol defined by a dynamic object and referenced by a
2018 regular object. The current definition is in some section of the
2019 dynamic object, but we're not including those sections. We have to
2020 change the definition to something the rest of the link can
2021 understand. */
2023 static bool
2024 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2025 struct elf_link_hash_entry *h)
2027 bfd *dynobj;
2028 asection *s;
2029 struct alpha_elf_link_hash_entry *ah;
2031 dynobj = elf_hash_table(info)->dynobj;
2032 ah = (struct alpha_elf_link_hash_entry *)h;
2034 /* Now that we've seen all of the input symbols, finalize our decision
2035 about whether this symbol should get a .plt entry. Irritatingly, it
2036 is common for folk to leave undefined symbols in shared libraries,
2037 and they still expect lazy binding; accept undefined symbols in lieu
2038 of STT_FUNC. */
2039 if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2041 h->needs_plt = true;
2043 s = elf_hash_table(info)->splt;
2044 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2045 return false;
2047 /* We need one plt entry per got subsection. Delay allocation of
2048 the actual plt entries until size_plt_section, called from
2049 size_dynamic_sections or during relaxation. */
2051 return true;
2053 else
2054 h->needs_plt = false;
2056 /* If this is a weak symbol, and there is a real definition, the
2057 processor independent code will have arranged for us to see the
2058 real definition first, and we can just use the same value. */
2059 if (h->is_weakalias)
2061 struct elf_link_hash_entry *def = weakdef (h);
2062 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2063 h->root.u.def.section = def->root.u.def.section;
2064 h->root.u.def.value = def->root.u.def.value;
2065 return true;
2068 /* This is a reference to a symbol defined by a dynamic object which
2069 is not a function. The Alpha, since it uses .got entries for all
2070 symbols even in regular objects, does not need the hackery of a
2071 .dynbss section and COPY dynamic relocations. */
2073 return true;
2076 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2078 static void
2079 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2080 unsigned int st_other,
2081 bool definition,
2082 bool dynamic)
2084 if (!dynamic && definition)
2085 h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2086 | (st_other & ~ELF_ST_VISIBILITY (-1)));
2089 /* Symbol versioning can create new symbols, and make our old symbols
2090 indirect to the new ones. Consolidate the got and reloc information
2091 in these situations. */
2093 static void
2094 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2095 struct elf_link_hash_entry *dir,
2096 struct elf_link_hash_entry *ind)
2098 struct alpha_elf_link_hash_entry *hi
2099 = (struct alpha_elf_link_hash_entry *) ind;
2100 struct alpha_elf_link_hash_entry *hs
2101 = (struct alpha_elf_link_hash_entry *) dir;
2103 /* Do the merging in the superclass. */
2104 _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2106 /* Merge the flags. Whee. */
2107 hs->flags |= hi->flags;
2109 /* ??? It's unclear to me what's really supposed to happen when
2110 "merging" defweak and defined symbols, given that we don't
2111 actually throw away the defweak. This more-or-less copies
2112 the logic related to got and plt entries in the superclass. */
2113 if (ind->root.type != bfd_link_hash_indirect)
2114 return;
2116 /* Merge the .got entries. Cannibalize the old symbol's list in
2117 doing so, since we don't need it anymore. */
2119 if (hs->got_entries == NULL)
2120 hs->got_entries = hi->got_entries;
2121 else
2123 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2125 gsh = hs->got_entries;
2126 for (gi = hi->got_entries; gi ; gi = gin)
2128 gin = gi->next;
2129 for (gs = gsh; gs ; gs = gs->next)
2130 if (gi->gotobj == gs->gotobj
2131 && gi->reloc_type == gs->reloc_type
2132 && gi->addend == gs->addend)
2134 gs->use_count += gi->use_count;
2135 goto got_found;
2137 gi->next = hs->got_entries;
2138 hs->got_entries = gi;
2139 got_found:;
2142 hi->got_entries = NULL;
2144 /* And similar for the reloc entries. */
2146 if (hs->reloc_entries == NULL)
2147 hs->reloc_entries = hi->reloc_entries;
2148 else
2150 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2152 rsh = hs->reloc_entries;
2153 for (ri = hi->reloc_entries; ri ; ri = rin)
2155 rin = ri->next;
2156 for (rs = rsh; rs ; rs = rs->next)
2157 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2159 rs->count += ri->count;
2160 goto found_reloc;
2162 ri->next = hs->reloc_entries;
2163 hs->reloc_entries = ri;
2164 found_reloc:;
2167 hi->reloc_entries = NULL;
2170 /* Is it possible to merge two object file's .got tables? */
2172 static bool
2173 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2175 int total = alpha_elf_tdata (a)->total_got_size;
2176 bfd *bsub;
2178 /* Trivial quick fallout test. */
2179 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2180 return true;
2182 /* By their nature, local .got entries cannot be merged. */
2183 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2184 return false;
2186 /* Failing the common trivial comparison, we must effectively
2187 perform the merge. Not actually performing the merge means that
2188 we don't have to store undo information in case we fail. */
2189 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2191 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2192 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2193 int i, n;
2195 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2196 for (i = 0; i < n; ++i)
2198 struct alpha_elf_got_entry *ae, *be;
2199 struct alpha_elf_link_hash_entry *h;
2201 h = hashes[i];
2202 while (h->root.root.type == bfd_link_hash_indirect
2203 || h->root.root.type == bfd_link_hash_warning)
2204 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2206 for (be = h->got_entries; be ; be = be->next)
2208 if (be->use_count == 0)
2209 continue;
2210 if (be->gotobj != b)
2211 continue;
2213 for (ae = h->got_entries; ae ; ae = ae->next)
2214 if (ae->gotobj == a
2215 && ae->reloc_type == be->reloc_type
2216 && ae->addend == be->addend)
2217 goto global_found;
2219 total += alpha_got_entry_size (be->reloc_type);
2220 if (total > MAX_GOT_SIZE)
2221 return false;
2222 global_found:;
2227 return true;
2230 /* Actually merge two .got tables. */
2232 static void
2233 elf64_alpha_merge_gots (bfd *a, bfd *b)
2235 int total = alpha_elf_tdata (a)->total_got_size;
2236 bfd *bsub;
2238 /* Remember local expansion. */
2240 int e = alpha_elf_tdata (b)->local_got_size;
2241 total += e;
2242 alpha_elf_tdata (a)->local_got_size += e;
2245 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2247 struct alpha_elf_got_entry **local_got_entries;
2248 struct alpha_elf_link_hash_entry **hashes;
2249 Elf_Internal_Shdr *symtab_hdr;
2250 int i, n;
2252 /* Let the local .got entries know they are part of a new subsegment. */
2253 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2254 if (local_got_entries)
2256 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2257 for (i = 0; i < n; ++i)
2259 struct alpha_elf_got_entry *ent;
2260 for (ent = local_got_entries[i]; ent; ent = ent->next)
2261 ent->gotobj = a;
2265 /* Merge the global .got entries. */
2266 hashes = alpha_elf_sym_hashes (bsub);
2267 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2269 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2270 for (i = 0; i < n; ++i)
2272 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2273 struct alpha_elf_link_hash_entry *h;
2275 h = hashes[i];
2276 while (h->root.root.type == bfd_link_hash_indirect
2277 || h->root.root.type == bfd_link_hash_warning)
2278 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2280 pbe = start = &h->got_entries;
2281 while ((be = *pbe) != NULL)
2283 if (be->use_count == 0)
2285 *pbe = be->next;
2286 memset (be, 0xa5, sizeof (*be));
2287 goto kill;
2289 if (be->gotobj != b)
2290 goto next;
2292 for (ae = *start; ae ; ae = ae->next)
2293 if (ae->gotobj == a
2294 && ae->reloc_type == be->reloc_type
2295 && ae->addend == be->addend)
2297 ae->flags |= be->flags;
2298 ae->use_count += be->use_count;
2299 *pbe = be->next;
2300 memset (be, 0xa5, sizeof (*be));
2301 goto kill;
2303 be->gotobj = a;
2304 total += alpha_got_entry_size (be->reloc_type);
2306 next:;
2307 pbe = &be->next;
2308 kill:;
2312 alpha_elf_tdata (bsub)->gotobj = a;
2314 alpha_elf_tdata (a)->total_got_size = total;
2316 /* Merge the two in_got chains. */
2318 bfd *next;
2320 bsub = a;
2321 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2322 bsub = next;
2324 alpha_elf_tdata (bsub)->in_got_link_next = b;
2328 /* Calculate the offsets for the got entries. */
2330 static bool
2331 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2332 void * arg ATTRIBUTE_UNUSED)
2334 struct alpha_elf_got_entry *gotent;
2336 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2337 if (gotent->use_count > 0)
2339 struct alpha_elf_obj_tdata *td;
2340 bfd_size_type *plge;
2342 td = alpha_elf_tdata (gotent->gotobj);
2343 plge = &td->got->size;
2344 gotent->got_offset = *plge;
2345 *plge += alpha_got_entry_size (gotent->reloc_type);
2348 return true;
2351 static void
2352 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2354 bfd *i, *got_list;
2355 struct alpha_elf_link_hash_table * htab;
2357 htab = alpha_elf_hash_table (info);
2358 if (htab == NULL)
2359 return;
2360 got_list = htab->got_list;
2362 /* First, zero out the .got sizes, as we may be recalculating the
2363 .got after optimizing it. */
2364 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2365 alpha_elf_tdata(i)->got->size = 0;
2367 /* Next, fill in the offsets for all the global entries. */
2368 alpha_elf_link_hash_traverse (htab,
2369 elf64_alpha_calc_got_offsets_for_symbol,
2370 NULL);
2372 /* Finally, fill in the offsets for the local entries. */
2373 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2375 bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2376 bfd *j;
2378 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2380 struct alpha_elf_got_entry **local_got_entries, *gotent;
2381 int k, n;
2383 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2384 if (!local_got_entries)
2385 continue;
2387 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2388 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2389 if (gotent->use_count > 0)
2391 gotent->got_offset = got_offset;
2392 got_offset += alpha_got_entry_size (gotent->reloc_type);
2396 alpha_elf_tdata(i)->got->size = got_offset;
2400 /* Constructs the gots. */
2402 static bool
2403 elf64_alpha_size_got_sections (struct bfd_link_info *info,
2404 bool may_merge)
2406 bfd *i, *got_list, *cur_got_obj = NULL;
2407 struct alpha_elf_link_hash_table * htab;
2409 htab = alpha_elf_hash_table (info);
2410 if (htab == NULL)
2411 return false;
2412 got_list = htab->got_list;
2414 /* On the first time through, pretend we have an existing got list
2415 consisting of all of the input files. */
2416 if (got_list == NULL)
2418 for (i = info->input_bfds; i ; i = i->link.next)
2420 bfd *this_got;
2422 if (! is_alpha_elf (i))
2423 continue;
2425 this_got = alpha_elf_tdata (i)->gotobj;
2426 if (this_got == NULL)
2427 continue;
2429 /* We are assuming no merging has yet occurred. */
2430 BFD_ASSERT (this_got == i);
2432 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2434 /* Yikes! A single object file has too many entries. */
2435 _bfd_error_handler
2436 /* xgettext:c-format */
2437 (_("%pB: .got subsegment exceeds 64K (size %d)"),
2438 i, alpha_elf_tdata (this_got)->total_got_size);
2439 return false;
2442 if (got_list == NULL)
2443 got_list = this_got;
2444 else
2445 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2446 cur_got_obj = this_got;
2449 /* Strange degenerate case of no got references. */
2450 if (got_list == NULL)
2451 return true;
2453 htab->got_list = got_list;
2456 cur_got_obj = got_list;
2457 if (cur_got_obj == NULL)
2458 return false;
2460 if (may_merge)
2462 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2463 while (i != NULL)
2465 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2467 elf64_alpha_merge_gots (cur_got_obj, i);
2469 alpha_elf_tdata(i)->got->size = 0;
2470 i = alpha_elf_tdata(i)->got_link_next;
2471 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2473 else
2475 cur_got_obj = i;
2476 i = alpha_elf_tdata(i)->got_link_next;
2481 /* Once the gots have been merged, fill in the got offsets for
2482 everything therein. */
2483 elf64_alpha_calc_got_offsets (info);
2485 return true;
2488 static bool
2489 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2490 void * data)
2492 asection *splt = (asection *) data;
2493 struct alpha_elf_got_entry *gotent;
2494 bool saw_one = false;
2496 /* If we didn't need an entry before, we still don't. */
2497 if (!h->root.needs_plt)
2498 return true;
2500 /* For each LITERAL got entry still in use, allocate a plt entry. */
2501 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2502 if (gotent->reloc_type == R_ALPHA_LITERAL
2503 && gotent->use_count > 0)
2505 if (splt->size == 0)
2506 splt->size = PLT_HEADER_SIZE;
2507 gotent->plt_offset = splt->size;
2508 splt->size += PLT_ENTRY_SIZE;
2509 saw_one = true;
2512 /* If there weren't any, there's no longer a need for the PLT entry. */
2513 if (!saw_one)
2514 h->root.needs_plt = false;
2516 return true;
2519 /* Called from relax_section to rebuild the PLT in light of potential changes
2520 in the function's status. */
2522 static void
2523 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2525 asection *splt, *spltrel, *sgotplt;
2526 unsigned long entries;
2527 struct alpha_elf_link_hash_table * htab;
2529 htab = alpha_elf_hash_table (info);
2530 if (htab == NULL)
2531 return;
2533 splt = elf_hash_table(info)->splt;
2534 if (splt == NULL)
2535 return;
2537 splt->size = 0;
2539 alpha_elf_link_hash_traverse (htab,
2540 elf64_alpha_size_plt_section_1, splt);
2542 /* Every plt entry requires a JMP_SLOT relocation. */
2543 spltrel = elf_hash_table(info)->srelplt;
2544 entries = 0;
2545 if (splt->size)
2547 if (elf64_alpha_use_secureplt)
2548 entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2549 else
2550 entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2552 spltrel->size = entries * sizeof (Elf64_External_Rela);
2554 /* When using the secureplt, we need two words somewhere in the data
2555 segment for the dynamic linker to tell us where to go. This is the
2556 entire contents of the .got.plt section. */
2557 if (elf64_alpha_use_secureplt)
2559 sgotplt = elf_hash_table(info)->sgotplt;
2560 sgotplt->size = entries ? 16 : 0;
2564 static bool
2565 elf64_alpha_early_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2566 struct bfd_link_info *info)
2568 bfd *i;
2569 struct alpha_elf_link_hash_table * htab;
2571 if (bfd_link_relocatable (info))
2572 return true;
2574 htab = alpha_elf_hash_table (info);
2575 if (htab == NULL)
2576 return false;
2578 if (!elf64_alpha_size_got_sections (info, true))
2579 return false;
2581 /* Allocate space for all of the .got subsections. */
2582 i = htab->got_list;
2583 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2585 asection *s = alpha_elf_tdata(i)->got;
2586 if (s->size > 0)
2588 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2589 if (s->contents == NULL)
2590 return false;
2594 return true;
2597 /* The number of dynamic relocations required by a static relocation. */
2599 static int
2600 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2602 switch (r_type)
2604 /* May appear in GOT entries. */
2605 case R_ALPHA_TLSGD:
2606 return (dynamic ? 2 : shared ? 1 : 0);
2607 case R_ALPHA_TLSLDM:
2608 return shared;
2609 case R_ALPHA_LITERAL:
2610 return dynamic || shared;
2611 case R_ALPHA_GOTTPREL:
2612 return dynamic || (shared && !pie);
2613 case R_ALPHA_GOTDTPREL:
2614 return dynamic;
2616 /* May appear in data sections. */
2617 case R_ALPHA_REFLONG:
2618 case R_ALPHA_REFQUAD:
2619 return dynamic || shared;
2620 case R_ALPHA_TPREL64:
2621 return dynamic || (shared && !pie);
2623 /* Everything else is illegal. We'll issue an error during
2624 relocate_section. */
2625 default:
2626 return 0;
2630 /* Work out the sizes of the dynamic relocation entries. */
2632 static bool
2633 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2634 struct bfd_link_info *info)
2636 bool dynamic;
2637 struct alpha_elf_reloc_entry *relent;
2638 unsigned long entries;
2640 /* If the symbol was defined as a common symbol in a regular object
2641 file, and there was no definition in any dynamic object, then the
2642 linker will have allocated space for the symbol in a common
2643 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2644 set. This is done for dynamic symbols in
2645 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2646 symbols, somehow. */
2647 if (!h->root.def_regular
2648 && h->root.ref_regular
2649 && !h->root.def_dynamic
2650 && (h->root.root.type == bfd_link_hash_defined
2651 || h->root.root.type == bfd_link_hash_defweak)
2652 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2653 h->root.def_regular = 1;
2655 /* If the symbol is dynamic, we'll need all the relocations in their
2656 natural form. If this is a shared object, and it has been forced
2657 local, we'll need the same number of RELATIVE relocations. */
2658 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2660 /* If the symbol is a hidden undefined weak, then we never have any
2661 relocations. Avoid the loop which may want to add RELATIVE relocs
2662 based on bfd_link_pic (info). */
2663 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2664 return true;
2666 for (relent = h->reloc_entries; relent; relent = relent->next)
2668 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2669 bfd_link_pic (info),
2670 bfd_link_pie (info));
2671 if (entries)
2673 asection *sec = relent->sec;
2674 relent->srel->size +=
2675 entries * sizeof (Elf64_External_Rela) * relent->count;
2676 if ((sec->flags & SEC_READONLY) != 0)
2678 info->flags |= DT_TEXTREL;
2679 info->callbacks->minfo
2680 (_("%pB: dynamic relocation against `%pT' in "
2681 "read-only section `%pA'\n"),
2682 sec->owner, h->root.root.root.string, sec);
2687 return true;
2690 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2691 global symbols. */
2693 static bool
2694 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2695 struct bfd_link_info *info)
2697 bool dynamic;
2698 struct alpha_elf_got_entry *gotent;
2699 unsigned long entries;
2701 /* If we're using a plt for this symbol, then all of its relocations
2702 for its got entries go into .rela.plt. */
2703 if (h->root.needs_plt)
2704 return true;
2706 /* If the symbol is dynamic, we'll need all the relocations in their
2707 natural form. If this is a shared object, and it has been forced
2708 local, we'll need the same number of RELATIVE relocations. */
2709 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2711 /* If the symbol is a hidden undefined weak, then we never have any
2712 relocations. Avoid the loop which may want to add RELATIVE relocs
2713 based on bfd_link_pic (info). */
2714 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2715 return true;
2717 entries = 0;
2718 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2719 if (gotent->use_count > 0)
2720 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2721 bfd_link_pic (info),
2722 bfd_link_pie (info));
2724 if (entries > 0)
2726 asection *srel = elf_hash_table(info)->srelgot;
2727 BFD_ASSERT (srel != NULL);
2728 srel->size += sizeof (Elf64_External_Rela) * entries;
2731 return true;
2734 /* Set the sizes of the dynamic relocation sections. */
2736 static void
2737 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2739 unsigned long entries;
2740 bfd *i;
2741 asection *srel;
2742 struct alpha_elf_link_hash_table * htab;
2744 htab = alpha_elf_hash_table (info);
2745 if (htab == NULL)
2746 return;
2748 /* Shared libraries often require RELATIVE relocs, and some relocs
2749 require attention for the main application as well. */
2751 entries = 0;
2752 for (i = htab->got_list;
2753 i ; i = alpha_elf_tdata(i)->got_link_next)
2755 bfd *j;
2757 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2759 struct alpha_elf_got_entry **local_got_entries, *gotent;
2760 int k, n;
2762 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2763 if (!local_got_entries)
2764 continue;
2766 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2767 for (gotent = local_got_entries[k];
2768 gotent ; gotent = gotent->next)
2769 if (gotent->use_count > 0)
2770 entries += (alpha_dynamic_entries_for_reloc
2771 (gotent->reloc_type, 0, bfd_link_pic (info),
2772 bfd_link_pie (info)));
2776 srel = elf_hash_table(info)->srelgot;
2777 if (!srel)
2779 BFD_ASSERT (entries == 0);
2780 return;
2782 srel->size = sizeof (Elf64_External_Rela) * entries;
2784 /* Now do the non-local symbols. */
2785 alpha_elf_link_hash_traverse (htab,
2786 elf64_alpha_size_rela_got_1, info);
2789 /* Set the sizes of the dynamic sections. */
2791 static bool
2792 elf64_alpha_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2793 struct bfd_link_info *info)
2795 bfd *dynobj;
2796 asection *s;
2797 bool relplt, relocs;
2798 struct alpha_elf_link_hash_table * htab;
2800 htab = alpha_elf_hash_table (info);
2801 if (htab == NULL)
2802 return false;
2804 dynobj = elf_hash_table(info)->dynobj;
2805 if (dynobj == NULL)
2806 return true;
2808 if (elf_hash_table (info)->dynamic_sections_created)
2810 /* Set the contents of the .interp section to the interpreter. */
2811 if (bfd_link_executable (info) && !info->nointerp)
2813 s = bfd_get_linker_section (dynobj, ".interp");
2814 BFD_ASSERT (s != NULL);
2815 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2816 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2819 /* Now that we've seen all of the input files, we can decide which
2820 symbols need dynamic relocation entries and which don't. We've
2821 collected information in check_relocs that we can now apply to
2822 size the dynamic relocation sections. */
2823 alpha_elf_link_hash_traverse (htab,
2824 elf64_alpha_calc_dynrel_sizes, info);
2826 elf64_alpha_size_rela_got_section (info);
2827 elf64_alpha_size_plt_section (info);
2829 /* else we're not dynamic and by definition we don't need such things. */
2831 /* The check_relocs and adjust_dynamic_symbol entry points have
2832 determined the sizes of the various dynamic sections. Allocate
2833 memory for them. */
2834 relplt = false;
2835 relocs = false;
2836 for (s = dynobj->sections; s != NULL; s = s->next)
2838 const char *name;
2840 if (!(s->flags & SEC_LINKER_CREATED))
2841 continue;
2843 /* It's OK to base decisions on the section name, because none
2844 of the dynobj section names depend upon the input files. */
2845 name = bfd_section_name (s);
2847 if (startswith (name, ".rela"))
2849 if (s->size != 0)
2851 if (strcmp (name, ".rela.plt") == 0)
2852 relplt = true;
2853 else
2854 relocs = true;
2856 /* We use the reloc_count field as a counter if we need
2857 to copy relocs into the output file. */
2858 s->reloc_count = 0;
2861 else if (! startswith (name, ".got")
2862 && strcmp (name, ".plt") != 0
2863 && strcmp (name, ".dynbss") != 0)
2865 /* It's not one of our dynamic sections, so don't allocate space. */
2866 continue;
2869 if (s->size == 0)
2871 /* If we don't need this section, strip it from the output file.
2872 This is to handle .rela.bss and .rela.plt. We must create it
2873 in create_dynamic_sections, because it must be created before
2874 the linker maps input sections to output sections. The
2875 linker does that before adjust_dynamic_symbol is called, and
2876 it is that function which decides whether anything needs to
2877 go into these sections. */
2878 if (!startswith (name, ".got"))
2879 s->flags |= SEC_EXCLUDE;
2881 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2883 /* Allocate memory for the section contents. */
2884 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2885 if (s->contents == NULL)
2886 return false;
2890 if (elf_hash_table (info)->dynamic_sections_created)
2892 /* Add some entries to the .dynamic section. We fill in the
2893 values later, in elf64_alpha_finish_dynamic_sections, but we
2894 must add the entries now so that we get the correct size for
2895 the .dynamic section. The DT_DEBUG entry is filled in by the
2896 dynamic linker and used by the debugger. */
2897 #define add_dynamic_entry(TAG, VAL) \
2898 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2900 if (!_bfd_elf_add_dynamic_tags (output_bfd, info,
2901 relocs || relplt))
2902 return false;
2904 if (relplt
2905 && elf64_alpha_use_secureplt
2906 && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2907 return false;
2909 #undef add_dynamic_entry
2911 return true;
2914 /* These functions do relaxation for Alpha ELF.
2916 Currently I'm only handling what I can do with existing compiler
2917 and assembler support, which means no instructions are removed,
2918 though some may be nopped. At this time GCC does not emit enough
2919 information to do all of the relaxing that is possible. It will
2920 take some not small amount of work for that to happen.
2922 There are a couple of interesting papers that I once read on this
2923 subject, that I cannot find references to at the moment, that
2924 related to Alpha in particular. They are by David Wall, then of
2925 DEC WRL. */
2927 struct alpha_relax_info
2929 bfd *abfd;
2930 asection *sec;
2931 bfd_byte *contents;
2932 Elf_Internal_Shdr *symtab_hdr;
2933 Elf_Internal_Rela *relocs, *relend;
2934 struct bfd_link_info *link_info;
2935 bfd_vma gp;
2936 bfd *gotobj;
2937 asection *tsec;
2938 struct alpha_elf_link_hash_entry *h;
2939 struct alpha_elf_got_entry **first_gotent;
2940 struct alpha_elf_got_entry *gotent;
2941 bool changed_contents;
2942 bool changed_relocs;
2943 unsigned char other;
2946 static Elf_Internal_Rela *
2947 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
2948 Elf_Internal_Rela *relend,
2949 bfd_vma offset, int type)
2951 while (rel < relend)
2953 if (rel->r_offset == offset
2954 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
2955 return rel;
2956 ++rel;
2958 return NULL;
2961 static bool
2962 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
2963 Elf_Internal_Rela *irel, unsigned long r_type)
2965 unsigned int insn;
2966 bfd_signed_vma disp;
2968 /* Get the instruction. */
2969 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
2971 if (insn >> 26 != OP_LDQ)
2973 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
2974 _bfd_error_handler
2975 /* xgettext:c-format */
2976 (_("%pB: %pA+%#" PRIx64 ": warning: "
2977 "%s relocation against unexpected insn"),
2978 info->abfd, info->sec, (uint64_t) irel->r_offset, howto->name);
2979 return true;
2982 /* Can't relax dynamic symbols. */
2983 if (info->h != NULL
2984 && alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
2985 return true;
2987 /* Can't use local-exec relocations in shared libraries. */
2988 if (r_type == R_ALPHA_GOTTPREL
2989 && bfd_link_dll (info->link_info))
2990 return true;
2992 if (r_type == R_ALPHA_LITERAL)
2994 /* Look for nice constant addresses. This includes the not-uncommon
2995 special case of 0 for undefweak symbols. */
2996 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
2997 || (!bfd_link_pic (info->link_info)
2998 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3000 disp = 0;
3001 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3002 insn |= (symval & 0xffff);
3003 r_type = R_ALPHA_NONE;
3005 else
3007 /* We may only create GPREL relocs during the second pass. */
3008 if (info->link_info->relax_pass == 0)
3009 return true;
3011 disp = symval - info->gp;
3012 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3013 r_type = R_ALPHA_GPREL16;
3016 else
3018 bfd_vma dtp_base, tp_base;
3020 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3021 dtp_base = alpha_get_dtprel_base (info->link_info);
3022 tp_base = alpha_get_tprel_base (info->link_info);
3023 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3025 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3027 switch (r_type)
3029 case R_ALPHA_GOTDTPREL:
3030 r_type = R_ALPHA_DTPREL16;
3031 break;
3032 case R_ALPHA_GOTTPREL:
3033 r_type = R_ALPHA_TPREL16;
3034 break;
3035 default:
3036 BFD_ASSERT (0);
3037 return false;
3041 if (disp < -0x8000 || disp >= 0x8000)
3042 return true;
3044 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3045 info->changed_contents = true;
3047 /* Reduce the use count on this got entry by one, possibly
3048 eliminating it. */
3049 if (--info->gotent->use_count == 0)
3051 int sz = alpha_got_entry_size (r_type);
3052 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3053 if (!info->h)
3054 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3057 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3058 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3059 info->changed_relocs = true;
3061 /* ??? Search forward through this basic block looking for insns
3062 that use the target register. Stop after an insn modifying the
3063 register is seen, or after a branch or call.
3065 Any such memory load insn may be substituted by a load directly
3066 off the GP. This allows the memory load insn to be issued before
3067 the calculated GP register would otherwise be ready.
3069 Any such jsr insn can be replaced by a bsr if it is in range.
3071 This would mean that we'd have to _add_ relocations, the pain of
3072 which gives one pause. */
3074 return true;
3077 static bfd_vma
3078 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3080 /* If the function has the same gp, and we can identify that the
3081 function does not use its function pointer, we can eliminate the
3082 address load. */
3084 /* If the symbol is marked NOPV, we are being told the function never
3085 needs its procedure value. */
3086 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3087 return symval;
3089 /* If the symbol is marked STD_GP, we are being told the function does
3090 a normal ldgp in the first two words. */
3091 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3094 /* Otherwise, we may be able to identify a GP load in the first two
3095 words, which we can then skip. */
3096 else
3098 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3099 bfd_vma ofs;
3101 /* Load the relocations from the section that the target symbol is in. */
3102 if (info->sec == info->tsec)
3104 tsec_relocs = info->relocs;
3105 tsec_relend = info->relend;
3106 tsec_free = NULL;
3108 else
3110 tsec_relocs = (_bfd_elf_link_read_relocs
3111 (info->abfd, info->tsec, NULL,
3112 (Elf_Internal_Rela *) NULL,
3113 info->link_info->keep_memory));
3114 if (tsec_relocs == NULL)
3115 return 0;
3116 tsec_relend = tsec_relocs + info->tsec->reloc_count;
3117 tsec_free = (elf_section_data (info->tsec)->relocs == tsec_relocs
3118 ? NULL
3119 : tsec_relocs);
3122 /* Recover the symbol's offset within the section. */
3123 ofs = (symval - info->tsec->output_section->vma
3124 - info->tsec->output_offset);
3126 /* Look for a GPDISP reloc. */
3127 gpdisp = (elf64_alpha_find_reloc_at_ofs
3128 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3130 if (!gpdisp || gpdisp->r_addend != 4)
3132 free (tsec_free);
3133 return 0;
3135 free (tsec_free);
3138 /* We've now determined that we can skip an initial gp load. Verify
3139 that the call and the target use the same gp. */
3140 if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3141 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3142 return 0;
3144 return symval + 8;
3147 static bool
3148 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3149 bfd_vma symval, Elf_Internal_Rela *irel)
3151 Elf_Internal_Rela *urel, *erel, *irelend = info->relend;
3152 int flags;
3153 bfd_signed_vma disp;
3154 bool fits16;
3155 bool fits32;
3156 bool lit_reused = false;
3157 bool all_optimized = true;
3158 bool changed_contents;
3159 bool changed_relocs;
3160 bfd_byte *contents = info->contents;
3161 bfd *abfd = info->abfd;
3162 bfd_vma sec_output_vma;
3163 unsigned int lit_insn;
3164 int relax_pass;
3166 lit_insn = bfd_get_32 (abfd, contents + irel->r_offset);
3167 if (lit_insn >> 26 != OP_LDQ)
3169 _bfd_error_handler
3170 /* xgettext:c-format */
3171 (_("%pB: %pA+%#" PRIx64 ": warning: "
3172 "%s relocation against unexpected insn"),
3173 abfd, info->sec, (uint64_t) irel->r_offset, "LITERAL");
3174 return true;
3177 /* Can't relax dynamic symbols. */
3178 if (info->h != NULL
3179 && alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3180 return true;
3182 changed_contents = info->changed_contents;
3183 changed_relocs = info->changed_relocs;
3184 sec_output_vma = info->sec->output_section->vma + info->sec->output_offset;
3185 relax_pass = info->link_info->relax_pass;
3187 /* Summarize how this particular LITERAL is used. */
3188 for (erel = irel+1, flags = 0; erel < irelend; ++erel)
3190 if (ELF64_R_TYPE (erel->r_info) != R_ALPHA_LITUSE)
3191 break;
3192 if (erel->r_addend <= 6)
3193 flags |= 1 << erel->r_addend;
3196 /* A little preparation for the loop... */
3197 disp = symval - info->gp;
3199 for (urel = irel+1; urel < erel; ++urel)
3201 bfd_vma urel_r_offset = urel->r_offset;
3202 unsigned int insn;
3203 int insn_disp;
3204 bfd_signed_vma xdisp;
3205 Elf_Internal_Rela nrel;
3207 insn = bfd_get_32 (abfd, contents + urel_r_offset);
3209 switch (urel->r_addend)
3211 case LITUSE_ALPHA_ADDR:
3212 default:
3213 /* This type is really just a placeholder to note that all
3214 uses cannot be optimized, but to still allow some. */
3215 all_optimized = false;
3216 break;
3218 case LITUSE_ALPHA_BASE:
3219 /* We may only create GPREL relocs during the second pass. */
3220 if (relax_pass == 0)
3222 all_optimized = false;
3223 break;
3226 /* We can always optimize 16-bit displacements. */
3228 /* Extract the displacement from the instruction, sign-extending
3229 it if necessary, then test whether it is within 16 or 32 bits
3230 displacement from GP. */
3231 insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3233 xdisp = disp + insn_disp;
3234 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3235 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3236 && xdisp < 0x7fff8000);
3238 if (fits16)
3240 /* Take the op code and dest from this insn, take the base
3241 register from the literal insn. Leave the offset alone. */
3242 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3243 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3244 changed_contents = true;
3246 nrel = *urel;
3247 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3248 R_ALPHA_GPREL16);
3249 nrel.r_addend = irel->r_addend;
3251 /* As we adjust, move the reloc to the end so that we don't
3252 break the LITERAL+LITUSE chain. */
3253 if (urel < --erel)
3254 *urel-- = *erel;
3255 *erel = nrel;
3256 changed_relocs = true;
3259 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3260 else if (fits32 && !(flags & ~6))
3262 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3264 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3265 R_ALPHA_GPRELHIGH);
3266 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3267 bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset);
3268 lit_reused = true;
3269 changed_contents = true;
3271 /* Since all relocs must be optimized, don't bother swapping
3272 this relocation to the end. */
3273 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3274 R_ALPHA_GPRELLOW);
3275 urel->r_addend = irel->r_addend;
3276 changed_relocs = true;
3278 else
3279 all_optimized = false;
3280 break;
3282 case LITUSE_ALPHA_BYTOFF:
3283 /* We can always optimize byte instructions. */
3285 /* FIXME: sanity check the insn for byte op. Check that the
3286 literal dest reg is indeed Rb in the byte insn. */
3288 insn &= ~ (unsigned) 0x001ff000;
3289 insn |= ((symval & 7) << 13) | 0x1000;
3290 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3291 changed_contents = true;
3293 nrel = *urel;
3294 nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3295 nrel.r_addend = 0;
3297 /* As we adjust, move the reloc to the end so that we don't
3298 break the LITERAL+LITUSE chain. */
3299 if (urel < --erel)
3300 *urel-- = *erel;
3301 *erel = nrel;
3302 changed_relocs = true;
3303 break;
3305 case LITUSE_ALPHA_JSR:
3306 case LITUSE_ALPHA_TLSGD:
3307 case LITUSE_ALPHA_TLSLDM:
3308 case LITUSE_ALPHA_JSRDIRECT:
3310 bfd_vma optdest, org;
3311 bfd_signed_vma odisp;
3313 /* For undefined weak symbols, we're mostly interested in getting
3314 rid of the got entry whenever possible, so optimize this to a
3315 use of the zero register. */
3316 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3318 insn |= 31 << 16;
3319 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3321 changed_contents = true;
3322 break;
3325 /* If not zero, place to jump without needing pv. */
3326 optdest = elf64_alpha_relax_opt_call (info, symval);
3327 org = sec_output_vma + urel_r_offset + 4;
3328 odisp = (optdest ? optdest : symval) - org;
3330 if (odisp >= -0x400000 && odisp < 0x400000)
3332 Elf_Internal_Rela *xrel;
3334 /* Preserve branch prediction call stack when possible. */
3335 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3336 insn = (OP_BSR << 26) | (insn & 0x03e00000);
3337 else
3338 insn = (OP_BR << 26) | (insn & 0x03e00000);
3339 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3340 changed_contents = true;
3342 nrel = *urel;
3343 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3344 R_ALPHA_BRADDR);
3345 nrel.r_addend = irel->r_addend;
3347 if (optdest)
3348 nrel.r_addend += optdest - symval;
3349 else
3350 all_optimized = false;
3352 /* Kill any HINT reloc that might exist for this insn. */
3353 xrel = (elf64_alpha_find_reloc_at_ofs
3354 (info->relocs, info->relend, urel_r_offset,
3355 R_ALPHA_HINT));
3356 if (xrel)
3357 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3359 /* As we adjust, move the reloc to the end so that we don't
3360 break the LITERAL+LITUSE chain. */
3361 if (urel < --erel)
3362 *urel-- = *erel;
3363 *erel = nrel;
3365 info->changed_relocs = true;
3367 else
3368 all_optimized = false;
3370 /* Even if the target is not in range for a direct branch,
3371 if we share a GP, we can eliminate the gp reload. */
3372 if (optdest)
3374 Elf_Internal_Rela *gpdisp
3375 = (elf64_alpha_find_reloc_at_ofs
3376 (info->relocs, irelend, urel_r_offset + 4,
3377 R_ALPHA_GPDISP));
3378 if (gpdisp)
3380 bfd_byte *p_ldah = contents + gpdisp->r_offset;
3381 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3382 unsigned int ldah = bfd_get_32 (abfd, p_ldah);
3383 unsigned int lda = bfd_get_32 (abfd, p_lda);
3385 /* Verify that the instruction is "ldah $29,0($26)".
3386 Consider a function that ends in a noreturn call,
3387 and that the next function begins with an ldgp,
3388 and that by accident there is no padding between.
3389 In that case the insn would use $27 as the base. */
3390 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3392 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_ldah);
3393 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda);
3395 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3396 changed_contents = true;
3397 changed_relocs = true;
3402 break;
3406 /* If we reused the literal instruction, we must have optimized all. */
3407 BFD_ASSERT(!lit_reused || all_optimized);
3409 /* If all cases were optimized, we can reduce the use count on this
3410 got entry by one, possibly eliminating it. */
3411 if (all_optimized)
3413 if (--info->gotent->use_count == 0)
3415 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3416 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3417 if (!info->h)
3418 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3421 /* If the literal instruction is no longer needed (it may have been
3422 reused. We can eliminate it. */
3423 /* ??? For now, I don't want to deal with compacting the section,
3424 so just nop it out. */
3425 if (!lit_reused)
3427 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3428 changed_relocs = true;
3430 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset);
3431 changed_contents = true;
3435 info->changed_contents = changed_contents;
3436 info->changed_relocs = changed_relocs;
3438 if (all_optimized || relax_pass == 0)
3439 return true;
3440 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3443 static bool
3444 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3445 Elf_Internal_Rela *irel, bool is_gd)
3447 bfd_byte *pos[5];
3448 unsigned int insn, tlsgd_reg;
3449 Elf_Internal_Rela *gpdisp, *hint;
3450 bool dynamic, use_gottprel;
3451 unsigned long new_symndx;
3453 dynamic = (info->h != NULL
3454 && alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info));
3456 /* If a TLS symbol is accessed using IE at least once, there is no point
3457 to use dynamic model for it. */
3458 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3461 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3462 then we might as well relax to IE. */
3463 else if (bfd_link_pic (info->link_info) && !dynamic
3464 && (info->link_info->flags & DF_STATIC_TLS))
3467 /* Otherwise we must be building an executable to do anything. */
3468 else if (bfd_link_pic (info->link_info))
3469 return true;
3471 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3472 the matching LITUSE_TLS relocations. */
3473 if (irel + 2 >= info->relend)
3474 return true;
3475 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3476 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3477 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3478 return true;
3480 /* There must be a GPDISP relocation positioned immediately after the
3481 LITUSE relocation. */
3482 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3483 irel[2].r_offset + 4, R_ALPHA_GPDISP);
3484 if (!gpdisp)
3485 return true;
3487 pos[0] = info->contents + irel[0].r_offset;
3488 pos[1] = info->contents + irel[1].r_offset;
3489 pos[2] = info->contents + irel[2].r_offset;
3490 pos[3] = info->contents + gpdisp->r_offset;
3491 pos[4] = pos[3] + gpdisp->r_addend;
3493 /* Beware of the compiler hoisting part of the sequence out a loop
3494 and adjusting the destination register for the TLSGD insn. If this
3495 happens, there will be a move into $16 before the JSR insn, so only
3496 transformations of the first insn pair should use this register. */
3497 tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3498 tlsgd_reg = (tlsgd_reg >> 21) & 31;
3500 /* Generally, the positions are not allowed to be out of order, lest the
3501 modified insn sequence have different register lifetimes. We can make
3502 an exception when pos 1 is adjacent to pos 0. */
3503 if (pos[1] + 4 == pos[0])
3505 bfd_byte *tmp = pos[0];
3506 pos[0] = pos[1];
3507 pos[1] = tmp;
3509 if (pos[1] >= pos[2] || pos[2] >= pos[3])
3510 return true;
3512 /* Reduce the use count on the LITERAL relocation. Do this before we
3513 smash the symndx when we adjust the relocations below. */
3515 struct alpha_elf_got_entry *lit_gotent;
3516 struct alpha_elf_link_hash_entry *lit_h;
3517 unsigned long indx;
3519 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3520 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3521 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3523 while (lit_h->root.root.type == bfd_link_hash_indirect
3524 || lit_h->root.root.type == bfd_link_hash_warning)
3525 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3527 for (lit_gotent = lit_h->got_entries; lit_gotent ;
3528 lit_gotent = lit_gotent->next)
3529 if (lit_gotent->gotobj == info->gotobj
3530 && lit_gotent->reloc_type == R_ALPHA_LITERAL
3531 && lit_gotent->addend == irel[1].r_addend)
3532 break;
3533 BFD_ASSERT (lit_gotent);
3535 if (--lit_gotent->use_count == 0)
3537 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3538 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3542 /* Change
3544 lda $16,x($gp) !tlsgd!1
3545 ldq $27,__tls_get_addr($gp) !literal!1
3546 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3547 ldah $29,0($26) !gpdisp!2
3548 lda $29,0($29) !gpdisp!2
3550 ldq $16,x($gp) !gottprel
3551 unop
3552 call_pal rduniq
3553 addq $16,$0,$0
3554 unop
3555 or the first pair to
3556 lda $16,x($gp) !tprel
3557 unop
3559 ldah $16,x($gp) !tprelhi
3560 lda $16,x($16) !tprello
3562 as appropriate. */
3564 use_gottprel = false;
3565 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3567 /* Some compilers warn about a Boolean-looking expression being
3568 used in a switch. The explicit cast silences them. */
3569 switch ((int) (!dynamic && !bfd_link_pic (info->link_info)))
3571 case 1:
3573 bfd_vma tp_base;
3574 bfd_signed_vma disp;
3576 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3577 tp_base = alpha_get_tprel_base (info->link_info);
3578 disp = symval - tp_base;
3580 if (disp >= -0x8000 && disp < 0x8000)
3582 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3583 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3584 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3586 irel[0].r_offset = pos[0] - info->contents;
3587 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3588 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3589 break;
3591 else if (disp >= -(bfd_signed_vma) 0x80000000
3592 && disp < (bfd_signed_vma) 0x7fff8000
3593 && pos[0] + 4 == pos[1])
3595 insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3596 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3597 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3598 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3600 irel[0].r_offset = pos[0] - info->contents;
3601 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3602 irel[1].r_offset = pos[1] - info->contents;
3603 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3604 break;
3607 /* FALLTHRU */
3609 default:
3610 use_gottprel = true;
3612 insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3613 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3614 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3616 irel[0].r_offset = pos[0] - info->contents;
3617 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3618 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3619 break;
3622 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3624 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3625 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3627 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3629 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3630 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3632 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3633 irel[2].r_offset, R_ALPHA_HINT);
3634 if (hint)
3635 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3637 info->changed_contents = true;
3638 info->changed_relocs = true;
3640 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3641 if (--info->gotent->use_count == 0)
3643 int sz = alpha_got_entry_size (info->gotent->reloc_type);
3644 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3645 if (!info->h)
3646 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3649 /* If we've switched to a GOTTPREL relocation, increment the reference
3650 count on that got entry. */
3651 if (use_gottprel)
3653 struct alpha_elf_got_entry *tprel_gotent;
3655 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3656 tprel_gotent = tprel_gotent->next)
3657 if (tprel_gotent->gotobj == info->gotobj
3658 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3659 && tprel_gotent->addend == irel->r_addend)
3660 break;
3661 if (tprel_gotent)
3662 tprel_gotent->use_count++;
3663 else
3665 if (info->gotent->use_count == 0)
3666 tprel_gotent = info->gotent;
3667 else
3669 tprel_gotent = (struct alpha_elf_got_entry *)
3670 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3671 if (!tprel_gotent)
3672 return false;
3674 tprel_gotent->next = *info->first_gotent;
3675 *info->first_gotent = tprel_gotent;
3677 tprel_gotent->gotobj = info->gotobj;
3678 tprel_gotent->addend = irel->r_addend;
3679 tprel_gotent->got_offset = -1;
3680 tprel_gotent->reloc_done = 0;
3681 tprel_gotent->reloc_xlated = 0;
3684 tprel_gotent->use_count = 1;
3685 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3689 return true;
3692 static bool
3693 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3694 struct bfd_link_info *link_info, bool *again)
3696 Elf_Internal_Shdr *symtab_hdr;
3697 Elf_Internal_Rela *internal_relocs;
3698 Elf_Internal_Rela *irel, *irelend;
3699 Elf_Internal_Sym *isymbuf = NULL;
3700 struct alpha_elf_got_entry **local_got_entries;
3701 struct alpha_relax_info info;
3702 struct alpha_elf_link_hash_table * htab;
3703 int relax_pass;
3705 htab = alpha_elf_hash_table (link_info);
3706 if (htab == NULL)
3707 return false;
3709 /* There's nothing to change, yet. */
3710 *again = false;
3712 if (bfd_link_relocatable (link_info)
3713 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC | SEC_HAS_CONTENTS))
3714 != (SEC_CODE | SEC_RELOC | SEC_ALLOC | SEC_HAS_CONTENTS))
3715 || sec->reloc_count == 0)
3716 return true;
3718 BFD_ASSERT (is_alpha_elf (abfd));
3719 relax_pass = link_info->relax_pass;
3721 /* Make sure our GOT and PLT tables are up-to-date. */
3722 if (htab->relax_trip != link_info->relax_trip)
3724 htab->relax_trip = link_info->relax_trip;
3726 /* This should never fail after the initial round, since the only error
3727 is GOT overflow, and relaxation only shrinks the table. However, we
3728 may only merge got sections during the first pass. If we merge
3729 sections after we've created GPREL relocs, the GP for the merged
3730 section backs up which may put the relocs out of range. */
3731 if (!elf64_alpha_size_got_sections (link_info, relax_pass == 0))
3732 abort ();
3733 if (elf_hash_table (link_info)->dynamic_sections_created)
3735 elf64_alpha_size_plt_section (link_info);
3736 elf64_alpha_size_rela_got_section (link_info);
3740 symtab_hdr = &elf_symtab_hdr (abfd);
3741 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3743 /* Load the relocations for this section. */
3744 internal_relocs = (_bfd_elf_link_read_relocs
3745 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3746 link_info->keep_memory));
3747 if (internal_relocs == NULL)
3748 return false;
3750 memset(&info, 0, sizeof (info));
3751 info.abfd = abfd;
3752 info.sec = sec;
3753 info.link_info = link_info;
3754 info.symtab_hdr = symtab_hdr;
3755 info.relocs = internal_relocs;
3756 info.relend = irelend = internal_relocs + sec->reloc_count;
3758 /* Find the GP for this object. Do not store the result back via
3759 _bfd_set_gp_value, since this could change again before final. */
3760 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3761 if (info.gotobj)
3763 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3764 info.gp = (sgot->output_section->vma
3765 + sgot->output_offset
3766 + 0x8000);
3769 /* Get the section contents. */
3770 if (elf_section_data (sec)->this_hdr.contents != NULL)
3771 info.contents = elf_section_data (sec)->this_hdr.contents;
3772 else
3774 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3775 goto error_return;
3778 for (irel = internal_relocs; irel < irelend; irel++)
3780 bfd_vma symval;
3781 struct alpha_elf_got_entry *gotent;
3782 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3783 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3785 /* Early exit for unhandled or unrelaxable relocations. */
3786 if (r_type != R_ALPHA_LITERAL)
3788 /* We complete everything except LITERAL in the first pass. */
3789 if (relax_pass != 0)
3790 continue;
3791 if (r_type == R_ALPHA_TLSLDM)
3793 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3794 reloc to the STN_UNDEF (0) symbol so that they all match. */
3795 r_symndx = STN_UNDEF;
3797 else if (r_type != R_ALPHA_GOTDTPREL
3798 && r_type != R_ALPHA_GOTTPREL
3799 && r_type != R_ALPHA_TLSGD)
3800 continue;
3803 /* Get the value of the symbol referred to by the reloc. */
3804 if (r_symndx < symtab_hdr->sh_info)
3806 /* A local symbol. */
3807 Elf_Internal_Sym *isym;
3809 /* Read this BFD's local symbols. */
3810 if (isymbuf == NULL)
3812 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3813 if (isymbuf == NULL)
3814 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3815 symtab_hdr->sh_info, 0,
3816 NULL, NULL, NULL);
3817 if (isymbuf == NULL)
3818 goto error_return;
3821 isym = isymbuf + r_symndx;
3823 /* Given the symbol for a TLSLDM reloc is ignored, this also
3824 means forcing the symbol value to the tp base. */
3825 if (r_type == R_ALPHA_TLSLDM)
3827 info.tsec = bfd_abs_section_ptr;
3828 symval = alpha_get_tprel_base (info.link_info);
3830 else
3832 symval = isym->st_value;
3833 if (isym->st_shndx == SHN_UNDEF)
3834 continue;
3835 else if (isym->st_shndx == SHN_ABS)
3836 info.tsec = bfd_abs_section_ptr;
3837 else if (isym->st_shndx == SHN_COMMON)
3838 info.tsec = bfd_com_section_ptr;
3839 else
3840 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3843 info.h = NULL;
3844 info.other = isym->st_other;
3845 if (local_got_entries)
3846 info.first_gotent = &local_got_entries[r_symndx];
3847 else
3849 info.first_gotent = &info.gotent;
3850 info.gotent = NULL;
3853 else
3855 unsigned long indx;
3856 struct alpha_elf_link_hash_entry *h;
3858 indx = r_symndx - symtab_hdr->sh_info;
3859 h = alpha_elf_sym_hashes (abfd)[indx];
3860 BFD_ASSERT (h != NULL);
3862 while (h->root.root.type == bfd_link_hash_indirect
3863 || h->root.root.type == bfd_link_hash_warning)
3864 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3866 /* If the symbol is undefined, we can't do anything with it. */
3867 if (h->root.root.type == bfd_link_hash_undefined)
3868 continue;
3870 /* If the symbol isn't defined in the current module,
3871 again we can't do anything. */
3872 if (h->root.root.type == bfd_link_hash_undefweak)
3874 info.tsec = bfd_abs_section_ptr;
3875 symval = 0;
3877 else if (!h->root.def_regular)
3879 /* Except for TLSGD relocs, which can sometimes be
3880 relaxed to GOTTPREL relocs. */
3881 if (r_type != R_ALPHA_TLSGD)
3882 continue;
3883 info.tsec = bfd_abs_section_ptr;
3884 symval = 0;
3886 else
3888 info.tsec = h->root.root.u.def.section;
3889 symval = h->root.root.u.def.value;
3892 info.h = h;
3893 info.other = h->root.other;
3894 info.first_gotent = &h->got_entries;
3897 /* Search for the got entry to be used by this relocation. */
3898 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3899 if (gotent->gotobj == info.gotobj
3900 && gotent->reloc_type == r_type
3901 && gotent->addend == irel->r_addend)
3902 break;
3903 info.gotent = gotent;
3905 symval += info.tsec->output_section->vma + info.tsec->output_offset;
3906 symval += irel->r_addend;
3908 switch (r_type)
3910 case R_ALPHA_LITERAL:
3911 BFD_ASSERT(info.gotent != NULL);
3913 /* If there exist LITUSE relocations immediately following, this
3914 opens up all sorts of interesting optimizations, because we
3915 now know every location that this address load is used. */
3916 if (irel+1 < irelend
3917 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
3919 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
3920 goto error_return;
3922 else
3924 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3925 goto error_return;
3927 break;
3929 case R_ALPHA_GOTDTPREL:
3930 case R_ALPHA_GOTTPREL:
3931 BFD_ASSERT(info.gotent != NULL);
3932 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3933 goto error_return;
3934 break;
3936 case R_ALPHA_TLSGD:
3937 case R_ALPHA_TLSLDM:
3938 BFD_ASSERT(info.gotent != NULL);
3939 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
3940 r_type == R_ALPHA_TLSGD))
3941 goto error_return;
3942 break;
3946 if (isymbuf != NULL
3947 && symtab_hdr->contents != (unsigned char *) isymbuf)
3949 if (!link_info->keep_memory)
3950 free (isymbuf);
3951 else
3953 /* Cache the symbols for elf_link_input_bfd. */
3954 symtab_hdr->contents = (unsigned char *) isymbuf;
3958 if (info.contents != NULL
3959 && elf_section_data (sec)->this_hdr.contents != info.contents)
3961 if (!info.changed_contents && !link_info->keep_memory)
3962 free (info.contents);
3963 else
3965 /* Cache the section contents for elf_link_input_bfd. */
3966 elf_section_data (sec)->this_hdr.contents = info.contents;
3970 if (elf_section_data (sec)->relocs != internal_relocs)
3972 if (!info.changed_relocs)
3973 free (internal_relocs);
3974 else
3975 elf_section_data (sec)->relocs = internal_relocs;
3978 *again = info.changed_contents || info.changed_relocs;
3980 return true;
3982 error_return:
3983 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3984 free (isymbuf);
3985 if (elf_section_data (sec)->this_hdr.contents != info.contents)
3986 free (info.contents);
3987 if (elf_section_data (sec)->relocs != internal_relocs)
3988 free (internal_relocs);
3989 return false;
3992 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
3993 into the next available slot in SREL. */
3995 static void
3996 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
3997 asection *sec, asection *srel, bfd_vma offset,
3998 long dynindx, long rtype, bfd_vma addend)
4000 Elf_Internal_Rela outrel;
4001 bfd_byte *loc;
4003 BFD_ASSERT (srel != NULL);
4005 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4006 outrel.r_addend = addend;
4008 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4009 if ((offset | 1) != (bfd_vma) -1)
4010 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4011 else
4012 memset (&outrel, 0, sizeof (outrel));
4014 loc = srel->contents;
4015 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4016 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4017 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4020 /* Relocate an Alpha ELF section for a relocatable link.
4022 We don't have to change anything unless the reloc is against a section
4023 symbol, in which case we have to adjust according to where the section
4024 symbol winds up in the output section. */
4026 static int
4027 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4028 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4029 bfd *input_bfd, asection *input_section,
4030 bfd_byte *contents ATTRIBUTE_UNUSED,
4031 Elf_Internal_Rela *relocs,
4032 Elf_Internal_Sym *local_syms,
4033 asection **local_sections)
4035 unsigned long symtab_hdr_sh_info;
4036 Elf_Internal_Rela *rel;
4037 Elf_Internal_Rela *relend;
4038 struct elf_link_hash_entry **sym_hashes;
4039 bool ret_val = true;
4041 symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4042 sym_hashes = elf_sym_hashes (input_bfd);
4044 relend = relocs + input_section->reloc_count;
4045 for (rel = relocs; rel < relend; rel++)
4047 unsigned long r_symndx;
4048 Elf_Internal_Sym *sym;
4049 asection *sec;
4050 unsigned long r_type;
4052 r_type = ELF64_R_TYPE (rel->r_info);
4053 if (r_type >= R_ALPHA_max)
4055 _bfd_error_handler
4056 /* xgettext:c-format */
4057 (_("%pB: unsupported relocation type %#x"),
4058 input_bfd, (int) r_type);
4059 bfd_set_error (bfd_error_bad_value);
4060 ret_val = false;
4061 continue;
4064 /* The symbol associated with GPDISP and LITUSE is
4065 immaterial. Only the addend is significant. */
4066 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4067 continue;
4069 r_symndx = ELF64_R_SYM (rel->r_info);
4070 if (r_symndx < symtab_hdr_sh_info)
4072 sym = local_syms + r_symndx;
4073 sec = local_sections[r_symndx];
4075 else
4077 struct elf_link_hash_entry *h;
4079 h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4081 while (h->root.type == bfd_link_hash_indirect
4082 || h->root.type == bfd_link_hash_warning)
4083 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4085 if (h->root.type != bfd_link_hash_defined
4086 && h->root.type != bfd_link_hash_defweak)
4087 continue;
4089 sym = NULL;
4090 sec = h->root.u.def.section;
4093 if (sec != NULL && discarded_section (sec))
4094 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4095 rel, 1, relend,
4096 elf64_alpha_howto_table + r_type, 0,
4097 contents);
4099 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4100 rel->r_addend += sec->output_offset;
4103 return ret_val;
4106 /* Relocate an Alpha ELF section. */
4108 static int
4109 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4110 bfd *input_bfd, asection *input_section,
4111 bfd_byte *contents, Elf_Internal_Rela *relocs,
4112 Elf_Internal_Sym *local_syms,
4113 asection **local_sections)
4115 Elf_Internal_Shdr *symtab_hdr;
4116 Elf_Internal_Rela *rel;
4117 Elf_Internal_Rela *relend;
4118 asection *sgot, *srel, *srelgot;
4119 bfd *dynobj, *gotobj;
4120 bfd_vma gp, tp_base, dtp_base;
4121 struct alpha_elf_got_entry **local_got_entries;
4122 bool ret_val;
4124 BFD_ASSERT (is_alpha_elf (input_bfd));
4126 /* Handle relocatable links with a smaller loop. */
4127 if (bfd_link_relocatable (info))
4128 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4129 input_section, contents, relocs,
4130 local_syms, local_sections);
4132 /* This is a final link. */
4134 ret_val = true;
4136 symtab_hdr = &elf_symtab_hdr (input_bfd);
4138 dynobj = elf_hash_table (info)->dynobj;
4139 srelgot = elf_hash_table (info)->srelgot;
4141 if (input_section->flags & SEC_ALLOC)
4143 const char *section_name;
4144 section_name = (bfd_elf_string_from_elf_section
4145 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4146 _bfd_elf_single_rel_hdr (input_section)->sh_name));
4147 BFD_ASSERT(section_name != NULL);
4148 srel = bfd_get_linker_section (dynobj, section_name);
4150 else
4151 srel = NULL;
4153 /* Find the gp value for this input bfd. */
4154 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4155 if (gotobj)
4157 sgot = alpha_elf_tdata (gotobj)->got;
4158 gp = _bfd_get_gp_value (gotobj);
4159 if (gp == 0)
4161 gp = (sgot->output_section->vma
4162 + sgot->output_offset
4163 + 0x8000);
4164 _bfd_set_gp_value (gotobj, gp);
4167 else
4169 sgot = NULL;
4170 gp = 0;
4173 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4175 if (elf_hash_table (info)->tls_sec != NULL)
4177 dtp_base = alpha_get_dtprel_base (info);
4178 tp_base = alpha_get_tprel_base (info);
4180 else
4181 dtp_base = tp_base = 0;
4183 relend = relocs + input_section->reloc_count;
4184 for (rel = relocs; rel < relend; rel++)
4186 struct alpha_elf_link_hash_entry *h = NULL;
4187 struct alpha_elf_got_entry *gotent;
4188 bfd_reloc_status_type r;
4189 reloc_howto_type *howto;
4190 unsigned long r_symndx;
4191 Elf_Internal_Sym *sym = NULL;
4192 asection *sec = NULL;
4193 bfd_vma value;
4194 bfd_vma addend;
4195 bool dynamic_symbol_p;
4196 bool unresolved_reloc = false;
4197 bool undef_weak_ref = false;
4198 unsigned long r_type;
4200 r_type = ELF64_R_TYPE(rel->r_info);
4201 if (r_type >= R_ALPHA_max)
4203 _bfd_error_handler
4204 /* xgettext:c-format */
4205 (_("%pB: unsupported relocation type %#x"),
4206 input_bfd, (int) r_type);
4207 bfd_set_error (bfd_error_bad_value);
4208 ret_val = false;
4209 continue;
4212 howto = elf64_alpha_howto_table + r_type;
4213 r_symndx = ELF64_R_SYM(rel->r_info);
4215 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4216 reloc to the STN_UNDEF (0) symbol so that they all match. */
4217 if (r_type == R_ALPHA_TLSLDM)
4218 r_symndx = STN_UNDEF;
4220 if (r_symndx < symtab_hdr->sh_info)
4222 asection *msec;
4223 sym = local_syms + r_symndx;
4224 sec = local_sections[r_symndx];
4225 msec = sec;
4226 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4228 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4229 this is hackery from relax_section. Force the value to
4230 be the tls module base. */
4231 if (r_symndx == STN_UNDEF
4232 && (r_type == R_ALPHA_TLSLDM
4233 || r_type == R_ALPHA_GOTTPREL
4234 || r_type == R_ALPHA_TPREL64
4235 || r_type == R_ALPHA_TPRELHI
4236 || r_type == R_ALPHA_TPRELLO
4237 || r_type == R_ALPHA_TPREL16))
4238 value = dtp_base;
4240 if (local_got_entries)
4241 gotent = local_got_entries[r_symndx];
4242 else
4243 gotent = NULL;
4245 /* Need to adjust local GOT entries' addends for SEC_MERGE
4246 unless it has been done already. */
4247 if ((sec->flags & SEC_MERGE)
4248 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4249 && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4250 && gotent
4251 && !gotent->reloc_xlated)
4253 struct alpha_elf_got_entry *ent;
4255 for (ent = gotent; ent; ent = ent->next)
4257 ent->reloc_xlated = 1;
4258 if (ent->use_count == 0)
4259 continue;
4260 msec = sec;
4261 ent->addend =
4262 _bfd_merged_section_offset (output_bfd, &msec,
4263 elf_section_data (sec)->
4264 sec_info,
4265 sym->st_value + ent->addend);
4266 ent->addend -= sym->st_value;
4267 ent->addend += msec->output_section->vma
4268 + msec->output_offset
4269 - sec->output_section->vma
4270 - sec->output_offset;
4274 dynamic_symbol_p = false;
4276 else
4278 bool warned, ignored;
4279 struct elf_link_hash_entry *hh;
4280 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4282 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4283 r_symndx, symtab_hdr, sym_hashes,
4284 hh, sec, value,
4285 unresolved_reloc, warned, ignored);
4287 if (warned)
4288 continue;
4290 if (value == 0
4291 && ! unresolved_reloc
4292 && hh->root.type == bfd_link_hash_undefweak)
4293 undef_weak_ref = true;
4295 h = (struct alpha_elf_link_hash_entry *) hh;
4296 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4297 gotent = h->got_entries;
4300 if (sec != NULL && discarded_section (sec))
4301 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4302 rel, 1, relend, howto, 0, contents);
4304 addend = rel->r_addend;
4305 value += addend;
4307 /* Search for the proper got entry. */
4308 for (; gotent ; gotent = gotent->next)
4309 if (gotent->gotobj == gotobj
4310 && gotent->reloc_type == r_type
4311 && gotent->addend == addend)
4312 break;
4314 switch (r_type)
4316 case R_ALPHA_GPDISP:
4318 bfd_byte *p_ldah, *p_lda;
4320 BFD_ASSERT(gp != 0);
4322 value = (input_section->output_section->vma
4323 + input_section->output_offset
4324 + rel->r_offset);
4326 p_ldah = contents + rel->r_offset;
4327 p_lda = p_ldah + rel->r_addend;
4329 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4330 p_ldah, p_lda);
4332 break;
4334 case R_ALPHA_LITERAL:
4335 BFD_ASSERT(sgot != NULL);
4336 BFD_ASSERT(gp != 0);
4337 BFD_ASSERT(gotent != NULL);
4338 BFD_ASSERT(gotent->use_count >= 1);
4340 if (!gotent->reloc_done)
4342 gotent->reloc_done = 1;
4344 bfd_put_64 (output_bfd, value,
4345 sgot->contents + gotent->got_offset);
4347 /* If the symbol has been forced local, output a
4348 RELATIVE reloc, otherwise it will be handled in
4349 finish_dynamic_symbol. */
4350 if (bfd_link_pic (info)
4351 && !dynamic_symbol_p
4352 && !undef_weak_ref)
4353 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4354 gotent->got_offset, 0,
4355 R_ALPHA_RELATIVE, value);
4358 value = (sgot->output_section->vma
4359 + sgot->output_offset
4360 + gotent->got_offset);
4361 value -= gp;
4362 goto default_reloc;
4364 case R_ALPHA_GPREL32:
4365 case R_ALPHA_GPREL16:
4366 case R_ALPHA_GPRELLOW:
4367 if (dynamic_symbol_p)
4369 _bfd_error_handler
4370 /* xgettext:c-format */
4371 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4372 input_bfd, h->root.root.root.string);
4373 ret_val = false;
4375 BFD_ASSERT(gp != 0);
4376 value -= gp;
4377 goto default_reloc;
4379 case R_ALPHA_GPRELHIGH:
4380 if (dynamic_symbol_p)
4382 _bfd_error_handler
4383 /* xgettext:c-format */
4384 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4385 input_bfd, h->root.root.root.string);
4386 ret_val = false;
4388 BFD_ASSERT(gp != 0);
4389 value -= gp;
4390 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4391 goto default_reloc;
4393 case R_ALPHA_HINT:
4394 /* A call to a dynamic symbol is definitely out of range of
4395 the 16-bit displacement. Don't bother writing anything. */
4396 if (dynamic_symbol_p)
4398 r = bfd_reloc_ok;
4399 break;
4401 /* The regular PC-relative stuff measures from the start of
4402 the instruction rather than the end. */
4403 value -= 4;
4404 goto default_reloc;
4406 case R_ALPHA_BRADDR:
4407 if (dynamic_symbol_p)
4409 _bfd_error_handler
4410 /* xgettext:c-format */
4411 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4412 input_bfd, h->root.root.root.string);
4413 ret_val = false;
4415 /* The regular PC-relative stuff measures from the start of
4416 the instruction rather than the end. */
4417 value -= 4;
4418 goto default_reloc;
4420 case R_ALPHA_BRSGP:
4422 int other;
4423 const char *name;
4425 /* The regular PC-relative stuff measures from the start of
4426 the instruction rather than the end. */
4427 value -= 4;
4429 /* The source and destination gp must be the same. Note that
4430 the source will always have an assigned gp, since we forced
4431 one in check_relocs, but that the destination may not, as
4432 it might not have had any relocations at all. Also take
4433 care not to crash if H is an undefined symbol. */
4434 if (h != NULL && sec != NULL
4435 && alpha_elf_tdata (sec->owner)->gotobj
4436 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4438 _bfd_error_handler
4439 /* xgettext:c-format */
4440 (_("%pB: change in gp: BRSGP %s"),
4441 input_bfd, h->root.root.root.string);
4442 ret_val = false;
4445 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4446 if (h != NULL)
4447 other = h->root.other;
4448 else
4449 other = sym->st_other;
4450 switch (other & STO_ALPHA_STD_GPLOAD)
4452 case STO_ALPHA_NOPV:
4453 break;
4454 case STO_ALPHA_STD_GPLOAD:
4455 value += 8;
4456 break;
4457 default:
4458 if (h != NULL)
4459 name = h->root.root.root.string;
4460 else
4462 name = (bfd_elf_string_from_elf_section
4463 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4464 if (name == NULL)
4465 name = _("<unknown>");
4466 else if (name[0] == 0)
4467 name = bfd_section_name (sec);
4469 _bfd_error_handler
4470 /* xgettext:c-format */
4471 (_("%pB: !samegp reloc against symbol without .prologue: %s"),
4472 input_bfd, name);
4473 ret_val = false;
4474 break;
4477 goto default_reloc;
4480 case R_ALPHA_REFLONG:
4481 case R_ALPHA_REFQUAD:
4482 case R_ALPHA_DTPREL64:
4483 case R_ALPHA_TPREL64:
4485 long dynindx, dyntype = r_type;
4486 bfd_vma dynaddend;
4488 /* Careful here to remember RELATIVE relocations for global
4489 variables for symbolic shared objects. */
4491 if (dynamic_symbol_p)
4493 BFD_ASSERT(h->root.dynindx != -1);
4494 dynindx = h->root.dynindx;
4495 dynaddend = addend;
4496 addend = 0, value = 0;
4498 else if (r_type == R_ALPHA_DTPREL64)
4500 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4501 value -= dtp_base;
4502 goto default_reloc;
4504 else if (r_type == R_ALPHA_TPREL64)
4506 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4507 if (!bfd_link_dll (info))
4509 value -= tp_base;
4510 goto default_reloc;
4512 dynindx = 0;
4513 dynaddend = value - dtp_base;
4515 else if (bfd_link_pic (info)
4516 && r_symndx != STN_UNDEF
4517 && (input_section->flags & SEC_ALLOC)
4518 && !undef_weak_ref
4519 && !(unresolved_reloc
4520 && (_bfd_elf_section_offset (output_bfd, info,
4521 input_section,
4522 rel->r_offset)
4523 == (bfd_vma) -1)))
4525 if (r_type == R_ALPHA_REFLONG)
4527 _bfd_error_handler
4528 /* xgettext:c-format */
4529 (_("%pB: unhandled dynamic relocation against %s"),
4530 input_bfd,
4531 h->root.root.root.string);
4532 ret_val = false;
4534 dynindx = 0;
4535 dyntype = R_ALPHA_RELATIVE;
4536 dynaddend = value;
4538 else
4539 goto default_reloc;
4541 if (input_section->flags & SEC_ALLOC)
4542 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4543 srel, rel->r_offset, dynindx,
4544 dyntype, dynaddend);
4546 goto default_reloc;
4548 case R_ALPHA_SREL16:
4549 case R_ALPHA_SREL32:
4550 case R_ALPHA_SREL64:
4551 if (dynamic_symbol_p)
4553 _bfd_error_handler
4554 /* xgettext:c-format */
4555 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4556 input_bfd, h->root.root.root.string);
4557 ret_val = false;
4559 else if (bfd_link_pic (info)
4560 && undef_weak_ref)
4562 _bfd_error_handler
4563 /* xgettext:c-format */
4564 (_("%pB: pc-relative relocation against undefined weak symbol %s"),
4565 input_bfd, h->root.root.root.string);
4566 ret_val = false;
4570 /* ??? .eh_frame references to discarded sections will be smashed
4571 to relocations against SHN_UNDEF. The .eh_frame format allows
4572 NULL to be encoded as 0 in any format, so this works here. */
4573 if (r_symndx == STN_UNDEF
4574 || (unresolved_reloc
4575 && _bfd_elf_section_offset (output_bfd, info,
4576 input_section,
4577 rel->r_offset) == (bfd_vma) -1))
4578 howto = (elf64_alpha_howto_table
4579 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4580 goto default_reloc;
4582 case R_ALPHA_TLSLDM:
4583 /* Ignore the symbol for the relocation. The result is always
4584 the current module. */
4585 dynamic_symbol_p = 0;
4586 /* FALLTHRU */
4588 case R_ALPHA_TLSGD:
4589 if (!gotent->reloc_done)
4591 gotent->reloc_done = 1;
4593 /* Note that the module index for the main program is 1. */
4594 bfd_put_64 (output_bfd,
4595 !bfd_link_pic (info) && !dynamic_symbol_p,
4596 sgot->contents + gotent->got_offset);
4598 /* If the symbol has been forced local, output a
4599 DTPMOD64 reloc, otherwise it will be handled in
4600 finish_dynamic_symbol. */
4601 if (bfd_link_pic (info) && !dynamic_symbol_p)
4602 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4603 gotent->got_offset, 0,
4604 R_ALPHA_DTPMOD64, 0);
4606 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4607 value = 0;
4608 else
4610 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4611 value -= dtp_base;
4613 bfd_put_64 (output_bfd, value,
4614 sgot->contents + gotent->got_offset + 8);
4617 value = (sgot->output_section->vma
4618 + sgot->output_offset
4619 + gotent->got_offset);
4620 value -= gp;
4621 goto default_reloc;
4623 case R_ALPHA_DTPRELHI:
4624 case R_ALPHA_DTPRELLO:
4625 case R_ALPHA_DTPREL16:
4626 if (dynamic_symbol_p)
4628 _bfd_error_handler
4629 /* xgettext:c-format */
4630 (_("%pB: dtp-relative relocation against dynamic symbol %s"),
4631 input_bfd, h->root.root.root.string);
4632 ret_val = false;
4634 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4635 value -= dtp_base;
4636 if (r_type == R_ALPHA_DTPRELHI)
4637 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4638 goto default_reloc;
4640 case R_ALPHA_TPRELHI:
4641 case R_ALPHA_TPRELLO:
4642 case R_ALPHA_TPREL16:
4643 if (bfd_link_dll (info))
4645 _bfd_error_handler
4646 /* xgettext:c-format */
4647 (_("%pB: TLS local exec code cannot be linked into shared objects"),
4648 input_bfd);
4649 ret_val = false;
4651 else if (dynamic_symbol_p)
4653 _bfd_error_handler
4654 /* xgettext:c-format */
4655 (_("%pB: tp-relative relocation against dynamic symbol %s"),
4656 input_bfd, h->root.root.root.string);
4657 ret_val = false;
4659 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4660 value -= tp_base;
4661 if (r_type == R_ALPHA_TPRELHI)
4662 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4663 goto default_reloc;
4665 case R_ALPHA_GOTDTPREL:
4666 case R_ALPHA_GOTTPREL:
4667 BFD_ASSERT(sgot != NULL);
4668 BFD_ASSERT(gp != 0);
4669 BFD_ASSERT(gotent != NULL);
4670 BFD_ASSERT(gotent->use_count >= 1);
4672 if (!gotent->reloc_done)
4674 gotent->reloc_done = 1;
4676 if (dynamic_symbol_p)
4677 value = 0;
4678 else
4680 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4681 if (r_type == R_ALPHA_GOTDTPREL)
4682 value -= dtp_base;
4683 else if (bfd_link_executable (info))
4684 value -= tp_base;
4685 else
4687 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4688 gotent->got_offset, 0,
4689 R_ALPHA_TPREL64,
4690 value - dtp_base);
4691 value = 0;
4694 bfd_put_64 (output_bfd, value,
4695 sgot->contents + gotent->got_offset);
4698 value = (sgot->output_section->vma
4699 + sgot->output_offset
4700 + gotent->got_offset);
4701 value -= gp;
4702 goto default_reloc;
4704 default:
4705 default_reloc:
4706 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4707 contents, rel->r_offset, value, 0);
4708 break;
4711 switch (r)
4713 case bfd_reloc_ok:
4714 break;
4716 case bfd_reloc_overflow:
4718 const char *name;
4720 /* Don't warn if the overflow is due to pc relative reloc
4721 against discarded section. Section optimization code should
4722 handle it. */
4724 if (r_symndx < symtab_hdr->sh_info
4725 && sec != NULL && howto->pc_relative
4726 && discarded_section (sec))
4727 break;
4729 if (h != NULL)
4730 name = NULL;
4731 else
4733 name = (bfd_elf_string_from_elf_section
4734 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4735 if (name == NULL)
4736 return false;
4737 if (*name == '\0')
4738 name = bfd_section_name (sec);
4740 (*info->callbacks->reloc_overflow)
4741 (info, (h ? &h->root.root : NULL), name, howto->name,
4742 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4744 break;
4746 default:
4747 case bfd_reloc_outofrange:
4748 abort ();
4752 return ret_val;
4755 /* Finish up dynamic symbol handling. We set the contents of various
4756 dynamic sections here. */
4758 static bool
4759 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4760 struct elf_link_hash_entry *h,
4761 Elf_Internal_Sym *sym)
4763 struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4765 if (h->needs_plt)
4767 /* Fill in the .plt entry for this symbol. */
4768 asection *splt, *sgot, *srel;
4769 Elf_Internal_Rela outrel;
4770 bfd_byte *loc;
4771 bfd_vma got_addr, plt_addr;
4772 bfd_vma plt_index;
4773 struct alpha_elf_got_entry *gotent;
4775 BFD_ASSERT (h->dynindx != -1);
4777 splt = elf_hash_table (info)->splt;
4778 BFD_ASSERT (splt != NULL);
4779 srel = elf_hash_table (info)->srelplt;
4780 BFD_ASSERT (srel != NULL);
4782 for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4783 if (gotent->reloc_type == R_ALPHA_LITERAL
4784 && gotent->use_count > 0)
4786 unsigned int insn;
4787 int disp;
4789 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4790 BFD_ASSERT (sgot != NULL);
4792 BFD_ASSERT (gotent->got_offset != -1);
4793 BFD_ASSERT (gotent->plt_offset != -1);
4795 got_addr = (sgot->output_section->vma
4796 + sgot->output_offset
4797 + gotent->got_offset);
4798 plt_addr = (splt->output_section->vma
4799 + splt->output_offset
4800 + gotent->plt_offset);
4802 plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4804 /* Fill in the entry in the procedure linkage table. */
4805 if (elf64_alpha_use_secureplt)
4807 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4808 insn = INSN_AD (INSN_BR, 31, disp);
4809 bfd_put_32 (output_bfd, insn,
4810 splt->contents + gotent->plt_offset);
4812 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4813 / NEW_PLT_ENTRY_SIZE);
4815 else
4817 disp = -(gotent->plt_offset + 4);
4818 insn = INSN_AD (INSN_BR, 28, disp);
4819 bfd_put_32 (output_bfd, insn,
4820 splt->contents + gotent->plt_offset);
4821 bfd_put_32 (output_bfd, INSN_UNOP,
4822 splt->contents + gotent->plt_offset + 4);
4823 bfd_put_32 (output_bfd, INSN_UNOP,
4824 splt->contents + gotent->plt_offset + 8);
4826 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4827 / OLD_PLT_ENTRY_SIZE);
4830 /* Fill in the entry in the .rela.plt section. */
4831 outrel.r_offset = got_addr;
4832 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4833 outrel.r_addend = 0;
4835 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4836 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4838 /* Fill in the entry in the .got. */
4839 bfd_put_64 (output_bfd, plt_addr,
4840 sgot->contents + gotent->got_offset);
4843 else if (alpha_elf_dynamic_symbol_p (h, info))
4845 /* Fill in the dynamic relocations for this symbol's .got entries. */
4846 asection *srel;
4847 struct alpha_elf_got_entry *gotent;
4849 srel = elf_hash_table (info)->srelgot;
4850 BFD_ASSERT (srel != NULL);
4852 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4853 gotent != NULL;
4854 gotent = gotent->next)
4856 asection *sgot;
4857 long r_type;
4859 if (gotent->use_count == 0)
4860 continue;
4862 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4864 r_type = gotent->reloc_type;
4865 switch (r_type)
4867 case R_ALPHA_LITERAL:
4868 r_type = R_ALPHA_GLOB_DAT;
4869 break;
4870 case R_ALPHA_TLSGD:
4871 r_type = R_ALPHA_DTPMOD64;
4872 break;
4873 case R_ALPHA_GOTDTPREL:
4874 r_type = R_ALPHA_DTPREL64;
4875 break;
4876 case R_ALPHA_GOTTPREL:
4877 r_type = R_ALPHA_TPREL64;
4878 break;
4879 case R_ALPHA_TLSLDM:
4880 default:
4881 abort ();
4884 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4885 gotent->got_offset, h->dynindx,
4886 r_type, gotent->addend);
4888 if (gotent->reloc_type == R_ALPHA_TLSGD)
4889 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4890 gotent->got_offset + 8, h->dynindx,
4891 R_ALPHA_DTPREL64, gotent->addend);
4895 /* Mark some specially defined symbols as absolute. */
4896 if (h == elf_hash_table (info)->hdynamic
4897 || h == elf_hash_table (info)->hgot
4898 || h == elf_hash_table (info)->hplt)
4899 sym->st_shndx = SHN_ABS;
4901 return true;
4904 /* Finish up the dynamic sections. */
4906 static bool
4907 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
4908 struct bfd_link_info *info)
4910 bfd *dynobj;
4911 asection *sdyn;
4913 dynobj = elf_hash_table (info)->dynobj;
4914 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4916 if (elf_hash_table (info)->dynamic_sections_created)
4918 asection *splt, *sgotplt, *srelaplt;
4919 Elf64_External_Dyn *dyncon, *dynconend;
4920 bfd_vma plt_vma, gotplt_vma;
4922 splt = elf_hash_table (info)->splt;
4923 srelaplt = elf_hash_table (info)->srelplt;
4924 BFD_ASSERT (splt != NULL && sdyn != NULL);
4926 plt_vma = splt->output_section->vma + splt->output_offset;
4928 gotplt_vma = 0;
4929 if (elf64_alpha_use_secureplt)
4931 sgotplt = elf_hash_table (info)->sgotplt;
4932 BFD_ASSERT (sgotplt != NULL);
4933 if (sgotplt->size > 0)
4934 gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
4937 dyncon = (Elf64_External_Dyn *) sdyn->contents;
4938 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4939 for (; dyncon < dynconend; dyncon++)
4941 Elf_Internal_Dyn dyn;
4943 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4945 switch (dyn.d_tag)
4947 case DT_PLTGOT:
4948 dyn.d_un.d_ptr
4949 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
4950 break;
4951 case DT_PLTRELSZ:
4952 dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
4953 break;
4954 case DT_JMPREL:
4955 dyn.d_un.d_ptr = srelaplt ? (srelaplt->output_section->vma
4956 + srelaplt->output_offset) : 0;
4957 break;
4960 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
4963 /* Initialize the plt header. */
4964 if (splt->size > 0)
4966 unsigned int insn;
4967 int ofs;
4969 if (elf64_alpha_use_secureplt)
4971 ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
4973 insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
4974 bfd_put_32 (output_bfd, insn, splt->contents);
4976 insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
4977 bfd_put_32 (output_bfd, insn, splt->contents + 4);
4979 insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
4980 bfd_put_32 (output_bfd, insn, splt->contents + 8);
4982 insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
4983 bfd_put_32 (output_bfd, insn, splt->contents + 12);
4985 insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
4986 bfd_put_32 (output_bfd, insn, splt->contents + 16);
4988 insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
4989 bfd_put_32 (output_bfd, insn, splt->contents + 20);
4991 insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
4992 bfd_put_32 (output_bfd, insn, splt->contents + 24);
4994 insn = INSN_AB (INSN_JMP, 31, 27);
4995 bfd_put_32 (output_bfd, insn, splt->contents + 28);
4997 insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
4998 bfd_put_32 (output_bfd, insn, splt->contents + 32);
5000 else
5002 insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */
5003 bfd_put_32 (output_bfd, insn, splt->contents);
5005 insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5006 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5008 insn = INSN_UNOP;
5009 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5011 insn = INSN_AB (INSN_JMP, 27, 27);
5012 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5014 /* The next two words will be filled in by ld.so. */
5015 bfd_put_64 (output_bfd, 0, splt->contents + 16);
5016 bfd_put_64 (output_bfd, 0, splt->contents + 24);
5019 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5023 return true;
5026 /* We need to use a special link routine to handle the .mdebug section.
5027 We need to merge all instances of these sections together, not write
5028 them all out sequentially. */
5030 static bool
5031 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5033 asection *o;
5034 struct bfd_link_order *p;
5035 asection *mdebug_sec;
5036 struct ecoff_debug_info debug;
5037 const struct ecoff_debug_swap *swap
5038 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5039 HDRR *symhdr = &debug.symbolic_header;
5040 void * mdebug_handle = NULL;
5041 struct alpha_elf_link_hash_table * htab;
5043 htab = alpha_elf_hash_table (info);
5044 if (htab == NULL)
5045 return false;
5047 /* Go through the sections and collect the mdebug information. */
5048 mdebug_sec = NULL;
5049 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5051 if (strcmp (o->name, ".mdebug") == 0)
5053 struct extsym_info einfo;
5055 /* We have found the .mdebug section in the output file.
5056 Look through all the link_orders comprising it and merge
5057 the information together. */
5058 symhdr->magic = swap->sym_magic;
5059 /* FIXME: What should the version stamp be? */
5060 symhdr->vstamp = 0;
5061 symhdr->ilineMax = 0;
5062 symhdr->cbLine = 0;
5063 symhdr->idnMax = 0;
5064 symhdr->ipdMax = 0;
5065 symhdr->isymMax = 0;
5066 symhdr->ioptMax = 0;
5067 symhdr->iauxMax = 0;
5068 symhdr->issMax = 0;
5069 symhdr->issExtMax = 0;
5070 symhdr->ifdMax = 0;
5071 symhdr->crfd = 0;
5072 symhdr->iextMax = 0;
5074 /* We accumulate the debugging information itself in the
5075 debug_info structure. */
5076 debug.line = NULL;
5077 debug.external_dnr = NULL;
5078 debug.external_pdr = NULL;
5079 debug.external_sym = NULL;
5080 debug.external_opt = NULL;
5081 debug.external_aux = NULL;
5082 debug.ss = NULL;
5083 debug.ssext = debug.ssext_end = NULL;
5084 debug.external_fdr = NULL;
5085 debug.external_rfd = NULL;
5086 debug.external_ext = debug.external_ext_end = NULL;
5088 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5089 if (mdebug_handle == NULL)
5090 return false;
5092 if (1)
5094 asection *s;
5095 EXTR esym;
5096 bfd_vma last = 0;
5097 unsigned int i;
5098 static const char * const name[] =
5100 ".text", ".init", ".fini", ".data",
5101 ".rodata", ".sdata", ".sbss", ".bss"
5103 static const int sc[] = { scText, scInit, scFini, scData,
5104 scRData, scSData, scSBss, scBss };
5106 esym.jmptbl = 0;
5107 esym.cobol_main = 0;
5108 esym.weakext = 0;
5109 esym.reserved = 0;
5110 esym.ifd = ifdNil;
5111 esym.asym.iss = issNil;
5112 esym.asym.st = stLocal;
5113 esym.asym.reserved = 0;
5114 esym.asym.index = indexNil;
5115 for (i = 0; i < 8; i++)
5117 esym.asym.sc = sc[i];
5118 s = bfd_get_section_by_name (abfd, name[i]);
5119 if (s != NULL)
5121 esym.asym.value = s->vma;
5122 last = s->vma + s->size;
5124 else
5125 esym.asym.value = last;
5127 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5128 name[i], &esym))
5129 return false;
5133 for (p = o->map_head.link_order;
5134 p != (struct bfd_link_order *) NULL;
5135 p = p->next)
5137 asection *input_section;
5138 bfd *input_bfd;
5139 const struct ecoff_debug_swap *input_swap;
5140 struct ecoff_debug_info input_debug;
5141 char *eraw_src;
5142 char *eraw_end;
5144 if (p->type != bfd_indirect_link_order)
5146 if (p->type == bfd_data_link_order)
5147 continue;
5148 abort ();
5151 input_section = p->u.indirect.section;
5152 input_bfd = input_section->owner;
5154 if (! is_alpha_elf (input_bfd))
5155 /* I don't know what a non ALPHA ELF bfd would be
5156 doing with a .mdebug section, but I don't really
5157 want to deal with it. */
5158 continue;
5160 input_swap = (get_elf_backend_data (input_bfd)
5161 ->elf_backend_ecoff_debug_swap);
5163 BFD_ASSERT (p->size == input_section->size);
5165 /* The ECOFF linking code expects that we have already
5166 read in the debugging information and set up an
5167 ecoff_debug_info structure, so we do that now. */
5168 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5169 &input_debug))
5170 return false;
5172 if (! (bfd_ecoff_debug_accumulate
5173 (mdebug_handle, abfd, &debug, swap, input_bfd,
5174 &input_debug, input_swap, info)))
5175 return false;
5177 /* Loop through the external symbols. For each one with
5178 interesting information, try to find the symbol in
5179 the linker global hash table and save the information
5180 for the output external symbols. */
5181 eraw_src = (char *) input_debug.external_ext;
5182 eraw_end = (eraw_src
5183 + (input_debug.symbolic_header.iextMax
5184 * input_swap->external_ext_size));
5185 for (;
5186 eraw_src < eraw_end;
5187 eraw_src += input_swap->external_ext_size)
5189 EXTR ext;
5190 const char *name;
5191 struct alpha_elf_link_hash_entry *h;
5193 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5194 if (ext.asym.sc == scNil
5195 || ext.asym.sc == scUndefined
5196 || ext.asym.sc == scSUndefined)
5197 continue;
5199 name = input_debug.ssext + ext.asym.iss;
5200 h = alpha_elf_link_hash_lookup (htab, name, false, false, true);
5201 if (h == NULL || h->esym.ifd != -2)
5202 continue;
5204 if (ext.ifd != -1)
5206 BFD_ASSERT (ext.ifd
5207 < input_debug.symbolic_header.ifdMax);
5208 ext.ifd = input_debug.ifdmap[ext.ifd];
5211 h->esym = ext;
5214 /* Free up the information we just read. */
5215 free (input_debug.line);
5216 free (input_debug.external_dnr);
5217 free (input_debug.external_pdr);
5218 free (input_debug.external_sym);
5219 free (input_debug.external_opt);
5220 free (input_debug.external_aux);
5221 free (input_debug.ss);
5222 free (input_debug.ssext);
5223 free (input_debug.external_fdr);
5224 free (input_debug.external_rfd);
5225 free (input_debug.external_ext);
5227 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5228 elf_link_input_bfd ignores this section. */
5229 input_section->flags &=~ SEC_HAS_CONTENTS;
5232 /* Build the external symbol information. */
5233 einfo.abfd = abfd;
5234 einfo.info = info;
5235 einfo.debug = &debug;
5236 einfo.swap = swap;
5237 einfo.failed = false;
5238 elf_link_hash_traverse (elf_hash_table (info),
5239 elf64_alpha_output_extsym,
5240 &einfo);
5241 if (einfo.failed)
5242 return false;
5244 /* Set the size of the .mdebug section. */
5245 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5247 /* Skip this section later on (I don't think this currently
5248 matters, but someday it might). */
5249 o->map_head.link_order = (struct bfd_link_order *) NULL;
5251 mdebug_sec = o;
5255 /* Invoke the regular ELF backend linker to do all the work. */
5256 if (! bfd_elf_final_link (abfd, info))
5257 return false;
5259 /* Now write out the computed sections. */
5261 /* The .got subsections... */
5263 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5264 for (i = htab->got_list;
5265 i != NULL;
5266 i = alpha_elf_tdata(i)->got_link_next)
5268 asection *sgot;
5270 /* elf_bfd_final_link already did everything in dynobj. */
5271 if (i == dynobj)
5272 continue;
5274 sgot = alpha_elf_tdata(i)->got;
5275 if (! bfd_set_section_contents (abfd, sgot->output_section,
5276 sgot->contents,
5277 (file_ptr) sgot->output_offset,
5278 sgot->size))
5279 return false;
5283 if (mdebug_sec != (asection *) NULL)
5285 BFD_ASSERT (abfd->output_has_begun);
5286 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5287 swap, info,
5288 mdebug_sec->filepos))
5289 return false;
5291 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5294 return true;
5297 static enum elf_reloc_type_class
5298 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5299 const asection *rel_sec ATTRIBUTE_UNUSED,
5300 const Elf_Internal_Rela *rela)
5302 switch ((int) ELF64_R_TYPE (rela->r_info))
5304 case R_ALPHA_RELATIVE:
5305 return reloc_class_relative;
5306 case R_ALPHA_JMP_SLOT:
5307 return reloc_class_plt;
5308 case R_ALPHA_COPY:
5309 return reloc_class_copy;
5310 default:
5311 return reloc_class_normal;
5315 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5317 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5318 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5319 { NULL, 0, 0, 0, 0 }
5322 /* ECOFF swapping routines. These are used when dealing with the
5323 .mdebug section, which is in the ECOFF debugging format. Copied
5324 from elf32-mips.c. */
5325 static const struct ecoff_debug_swap
5326 elf64_alpha_ecoff_debug_swap =
5328 /* Symbol table magic number. */
5329 magicSym2,
5330 /* Alignment of debugging information. E.g., 4. */
5332 /* Sizes of external symbolic information. */
5333 sizeof (struct hdr_ext),
5334 sizeof (struct dnr_ext),
5335 sizeof (struct pdr_ext),
5336 sizeof (struct sym_ext),
5337 sizeof (struct opt_ext),
5338 sizeof (struct fdr_ext),
5339 sizeof (struct rfd_ext),
5340 sizeof (struct ext_ext),
5341 /* Functions to swap in external symbolic data. */
5342 ecoff_swap_hdr_in,
5343 ecoff_swap_dnr_in,
5344 ecoff_swap_pdr_in,
5345 ecoff_swap_sym_in,
5346 ecoff_swap_opt_in,
5347 ecoff_swap_fdr_in,
5348 ecoff_swap_rfd_in,
5349 ecoff_swap_ext_in,
5350 _bfd_ecoff_swap_tir_in,
5351 _bfd_ecoff_swap_rndx_in,
5352 /* Functions to swap out external symbolic data. */
5353 ecoff_swap_hdr_out,
5354 ecoff_swap_dnr_out,
5355 ecoff_swap_pdr_out,
5356 ecoff_swap_sym_out,
5357 ecoff_swap_opt_out,
5358 ecoff_swap_fdr_out,
5359 ecoff_swap_rfd_out,
5360 ecoff_swap_ext_out,
5361 _bfd_ecoff_swap_tir_out,
5362 _bfd_ecoff_swap_rndx_out,
5363 /* Function to read in symbolic data. */
5364 elf64_alpha_read_ecoff_info
5367 /* Use a non-standard hash bucket size of 8. */
5369 static const struct elf_size_info alpha_elf_size_info =
5371 sizeof (Elf64_External_Ehdr),
5372 sizeof (Elf64_External_Phdr),
5373 sizeof (Elf64_External_Shdr),
5374 sizeof (Elf64_External_Rel),
5375 sizeof (Elf64_External_Rela),
5376 sizeof (Elf64_External_Sym),
5377 sizeof (Elf64_External_Dyn),
5378 sizeof (Elf_External_Note),
5381 64, 3,
5382 ELFCLASS64, EV_CURRENT,
5383 bfd_elf64_write_out_phdrs,
5384 bfd_elf64_write_shdrs_and_ehdr,
5385 bfd_elf64_checksum_contents,
5386 bfd_elf64_write_relocs,
5387 bfd_elf64_swap_symbol_in,
5388 bfd_elf64_swap_symbol_out,
5389 bfd_elf64_slurp_reloc_table,
5390 bfd_elf64_slurp_symbol_table,
5391 bfd_elf64_swap_dyn_in,
5392 bfd_elf64_swap_dyn_out,
5393 bfd_elf64_swap_reloc_in,
5394 bfd_elf64_swap_reloc_out,
5395 bfd_elf64_swap_reloca_in,
5396 bfd_elf64_swap_reloca_out
5399 #define TARGET_LITTLE_SYM alpha_elf64_vec
5400 #define TARGET_LITTLE_NAME "elf64-alpha"
5401 #define ELF_ARCH bfd_arch_alpha
5402 #define ELF_TARGET_ID ALPHA_ELF_DATA
5403 #define ELF_MACHINE_CODE EM_ALPHA
5404 #define ELF_MAXPAGESIZE 0x10000
5405 #define ELF_COMMONPAGESIZE 0x2000
5407 #define bfd_elf64_bfd_link_hash_table_create \
5408 elf64_alpha_bfd_link_hash_table_create
5410 #define bfd_elf64_bfd_reloc_type_lookup \
5411 elf64_alpha_bfd_reloc_type_lookup
5412 #define bfd_elf64_bfd_reloc_name_lookup \
5413 elf64_alpha_bfd_reloc_name_lookup
5414 #define elf_info_to_howto \
5415 elf64_alpha_info_to_howto
5417 #define bfd_elf64_mkobject \
5418 elf64_alpha_mkobject
5419 #define elf_backend_object_p \
5420 elf64_alpha_object_p
5422 #define elf_backend_section_from_shdr \
5423 elf64_alpha_section_from_shdr
5424 #define elf_backend_section_flags \
5425 elf64_alpha_section_flags
5426 #define elf_backend_fake_sections \
5427 elf64_alpha_fake_sections
5429 #define bfd_elf64_bfd_is_local_label_name \
5430 elf64_alpha_is_local_label_name
5431 #define bfd_elf64_find_nearest_line \
5432 elf64_alpha_find_nearest_line
5433 #define bfd_elf64_bfd_relax_section \
5434 elf64_alpha_relax_section
5436 #define elf_backend_add_symbol_hook \
5437 elf64_alpha_add_symbol_hook
5438 #define elf_backend_relocs_compatible \
5439 _bfd_elf_relocs_compatible
5440 #define elf_backend_sort_relocs_p \
5441 elf64_alpha_sort_relocs_p
5442 #define elf_backend_check_relocs \
5443 elf64_alpha_check_relocs
5444 #define elf_backend_create_dynamic_sections \
5445 elf64_alpha_create_dynamic_sections
5446 #define elf_backend_adjust_dynamic_symbol \
5447 elf64_alpha_adjust_dynamic_symbol
5448 #define elf_backend_merge_symbol_attribute \
5449 elf64_alpha_merge_symbol_attribute
5450 #define elf_backend_copy_indirect_symbol \
5451 elf64_alpha_copy_indirect_symbol
5452 #define elf_backend_early_size_sections \
5453 elf64_alpha_early_size_sections
5454 #define elf_backend_late_size_sections \
5455 elf64_alpha_late_size_sections
5456 #define elf_backend_omit_section_dynsym \
5457 _bfd_elf_omit_section_dynsym_all
5458 #define elf_backend_relocate_section \
5459 elf64_alpha_relocate_section
5460 #define elf_backend_finish_dynamic_symbol \
5461 elf64_alpha_finish_dynamic_symbol
5462 #define elf_backend_finish_dynamic_sections \
5463 elf64_alpha_finish_dynamic_sections
5464 #define bfd_elf64_bfd_final_link \
5465 elf64_alpha_final_link
5466 #define elf_backend_reloc_type_class \
5467 elf64_alpha_reloc_type_class
5469 #define elf_backend_can_gc_sections 1
5470 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5472 #define elf_backend_ecoff_debug_swap \
5473 &elf64_alpha_ecoff_debug_swap
5475 #define elf_backend_size_info \
5476 alpha_elf_size_info
5478 #define elf_backend_special_sections \
5479 elf64_alpha_special_sections
5481 #define elf_backend_strip_zero_sized_dynamic_sections \
5482 _bfd_elf_strip_zero_sized_dynamic_sections
5484 /* A few constants that determine how the .plt section is set up. */
5485 #define elf_backend_want_got_plt 0
5486 #define elf_backend_plt_readonly 0
5487 #define elf_backend_want_plt_sym 1
5488 #define elf_backend_got_header_size 0
5489 #define elf_backend_dtrel_excludes_plt 1
5491 #include "elf64-target.h"
5493 /* FreeBSD support. */
5495 #undef TARGET_LITTLE_SYM
5496 #define TARGET_LITTLE_SYM alpha_elf64_fbsd_vec
5497 #undef TARGET_LITTLE_NAME
5498 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5499 #undef ELF_OSABI
5500 #define ELF_OSABI ELFOSABI_FREEBSD
5502 /* The kernel recognizes executables as valid only if they carry a
5503 "FreeBSD" label in the ELF header. So we put this label on all
5504 executables and (for simplicity) also all other object files. */
5506 static bool
5507 elf64_alpha_fbsd_init_file_header (bfd *abfd, struct bfd_link_info *info)
5509 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5511 if (!_bfd_elf_init_file_header (abfd, info))
5512 return false;
5514 i_ehdrp = elf_elfheader (abfd);
5516 /* Put an ABI label supported by FreeBSD >= 4.1. */
5517 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5518 #ifdef OLD_FREEBSD_ABI_LABEL
5519 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5520 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5521 #endif
5522 return true;
5525 #undef elf_backend_init_file_header
5526 #define elf_backend_init_file_header \
5527 elf64_alpha_fbsd_init_file_header
5529 #undef elf64_bed
5530 #define elf64_bed elf64_alpha_fbsd_bed
5532 #include "elf64-target.h"