1 /* Alpha specific support for 64-bit ELF
2 Copyright (C) 1996-2014 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. */
31 #include "elf/alpha.h"
35 #define NO_COFF_RELOCS
36 #define NO_COFF_SYMBOLS
37 #define NO_COFF_LINENOS
39 /* Get the ECOFF swapping routines. Needed for the debug information. */
40 #include "coff/internal.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
44 #include "coff/alpha.h"
49 #include "ecoffswap.h"
52 /* Instruction data for plt generation and relaxation. */
60 #define INSN_LDA (OP_LDA << 26)
61 #define INSN_LDAH (OP_LDAH << 26)
62 #define INSN_LDQ (OP_LDQ << 26)
63 #define INSN_BR (OP_BR << 26)
65 #define INSN_ADDQ 0x40000400
66 #define INSN_RDUNIQ 0x0000009e
67 #define INSN_SUBQ 0x40000520
68 #define INSN_S4SUBQ 0x40000560
69 #define INSN_UNOP 0x2ffe0000
71 #define INSN_JSR 0x68004000
72 #define INSN_JMP 0x68000000
73 #define INSN_JSR_MASK 0xfc00c000
75 #define INSN_A(I,A) (I | (A << 21))
76 #define INSN_AB(I,A,B) (I | (A << 21) | (B << 16))
77 #define INSN_ABC(I,A,B,C) (I | (A << 21) | (B << 16) | C)
78 #define INSN_ABO(I,A,B,O) (I | (A << 21) | (B << 16) | ((O) & 0xffff))
79 #define INSN_AD(I,A,D) (I | (A << 21) | (((D) >> 2) & 0x1fffff))
83 /* Set by ld emulation. Putting this into the link_info or hash structure
84 is simply working too hard. */
86 bfd_boolean elf64_alpha_use_secureplt = TRUE;
88 bfd_boolean elf64_alpha_use_secureplt = FALSE;
91 #define OLD_PLT_HEADER_SIZE 32
92 #define OLD_PLT_ENTRY_SIZE 12
93 #define NEW_PLT_HEADER_SIZE 36
94 #define NEW_PLT_ENTRY_SIZE 4
96 #define PLT_HEADER_SIZE \
97 (elf64_alpha_use_secureplt ? NEW_PLT_HEADER_SIZE : OLD_PLT_HEADER_SIZE)
98 #define PLT_ENTRY_SIZE \
99 (elf64_alpha_use_secureplt ? NEW_PLT_ENTRY_SIZE : OLD_PLT_ENTRY_SIZE)
101 #define MAX_GOT_SIZE (64*1024)
103 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
106 /* Used to implement multiple .got subsections. */
107 struct alpha_elf_got_entry
109 struct alpha_elf_got_entry *next;
111 /* Which .got subsection? */
114 /* The addend in effect for this entry. */
117 /* The .got offset for this entry. */
120 /* The .plt offset for this entry. */
123 /* How many references to this entry? */
126 /* The relocation type of this entry. */
127 unsigned char reloc_type;
129 /* How a LITERAL is used. */
132 /* Have we initialized the dynamic relocation for this entry? */
133 unsigned char reloc_done;
135 /* Have we adjusted this entry for SEC_MERGE? */
136 unsigned char reloc_xlated;
139 struct alpha_elf_reloc_entry
141 struct alpha_elf_reloc_entry *next;
143 /* Which .reloc section? */
146 /* What kind of relocation? */
149 /* Is this against read-only section? */
150 unsigned int reltext : 1;
152 /* How many did we find? */
156 struct alpha_elf_link_hash_entry
158 struct elf_link_hash_entry root;
160 /* External symbol information. */
163 /* Cumulative flags for all the .got entries. */
166 /* Contexts in which a literal was referenced. */
167 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
168 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
169 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
170 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
171 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
172 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
173 #define ALPHA_ELF_LINK_HASH_LU_JSRDIRECT 0x40
174 #define ALPHA_ELF_LINK_HASH_LU_PLT 0x38
175 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x80
177 /* Used to implement multiple .got subsections. */
178 struct alpha_elf_got_entry *got_entries;
180 /* Used to count non-got, non-plt relocations for delayed sizing
181 of relocation sections. */
182 struct alpha_elf_reloc_entry *reloc_entries;
185 /* Alpha ELF linker hash table. */
187 struct alpha_elf_link_hash_table
189 struct elf_link_hash_table root;
191 /* The head of a list of .got subsections linked through
192 alpha_elf_tdata(abfd)->got_link_next. */
195 /* The most recent relax pass that we've seen. The GOTs
196 should be regenerated if this doesn't match. */
200 /* Look up an entry in a Alpha ELF linker hash table. */
202 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
203 ((struct alpha_elf_link_hash_entry *) \
204 elf_link_hash_lookup (&(table)->root, (string), (create), \
207 /* Traverse a Alpha ELF linker hash table. */
209 #define alpha_elf_link_hash_traverse(table, func, info) \
210 (elf_link_hash_traverse \
212 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
215 /* Get the Alpha ELF linker hash table from a link_info structure. */
217 #define alpha_elf_hash_table(p) \
218 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
219 == ALPHA_ELF_DATA ? ((struct alpha_elf_link_hash_table *) ((p)->hash)) : NULL)
221 /* Get the object's symbols as our own entry type. */
223 #define alpha_elf_sym_hashes(abfd) \
224 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
226 /* Should we do dynamic things to this symbol? This differs from the
227 generic version in that we never need to consider function pointer
228 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
229 address is ever taken. */
231 static inline bfd_boolean
232 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
233 struct bfd_link_info *info)
235 return _bfd_elf_dynamic_symbol_p (h, info, 0);
238 /* Create an entry in a Alpha ELF linker hash table. */
240 static struct bfd_hash_entry *
241 elf64_alpha_link_hash_newfunc (struct bfd_hash_entry *entry,
242 struct bfd_hash_table *table,
245 struct alpha_elf_link_hash_entry *ret =
246 (struct alpha_elf_link_hash_entry *) entry;
248 /* Allocate the structure if it has not already been allocated by a
250 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
251 ret = ((struct alpha_elf_link_hash_entry *)
252 bfd_hash_allocate (table,
253 sizeof (struct alpha_elf_link_hash_entry)));
254 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
255 return (struct bfd_hash_entry *) ret;
257 /* Call the allocation method of the superclass. */
258 ret = ((struct alpha_elf_link_hash_entry *)
259 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
261 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
263 /* Set local fields. */
264 memset (&ret->esym, 0, sizeof (EXTR));
265 /* We use -2 as a marker to indicate that the information has
266 not been set. -1 means there is no associated ifd. */
269 ret->got_entries = NULL;
270 ret->reloc_entries = NULL;
273 return (struct bfd_hash_entry *) ret;
276 /* Create a Alpha ELF linker hash table. */
278 static struct bfd_link_hash_table *
279 elf64_alpha_bfd_link_hash_table_create (bfd *abfd)
281 struct alpha_elf_link_hash_table *ret;
282 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
284 ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
285 if (ret == (struct alpha_elf_link_hash_table *) NULL)
288 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
289 elf64_alpha_link_hash_newfunc,
290 sizeof (struct alpha_elf_link_hash_entry),
297 return &ret->root.root;
300 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
301 routine in order to handle the ECOFF debugging information. */
303 struct alpha_elf_find_line
305 struct ecoff_debug_info d;
306 struct ecoff_find_line i;
309 /* We have some private fields hanging off of the elf_tdata structure. */
311 struct alpha_elf_obj_tdata
313 struct elf_obj_tdata root;
315 /* For every input file, these are the got entries for that object's
317 struct alpha_elf_got_entry ** local_got_entries;
319 /* For every input file, this is the object that owns the got that
320 this input file uses. */
323 /* For every got, this is a linked list through the objects using this got */
324 bfd *in_got_link_next;
326 /* For every got, this is a link to the next got subsegment. */
329 /* For every got, this is the section. */
332 /* For every got, this is it's total number of words. */
335 /* For every got, this is the sum of the number of words required
336 to hold all of the member object's local got. */
339 /* Used by elf64_alpha_find_nearest_line entry point. */
340 struct alpha_elf_find_line *find_line_info;
344 #define alpha_elf_tdata(abfd) \
345 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
347 #define is_alpha_elf(bfd) \
348 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
349 && elf_tdata (bfd) != NULL \
350 && elf_object_id (bfd) == ALPHA_ELF_DATA)
353 elf64_alpha_mkobject (bfd *abfd)
355 return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
360 elf64_alpha_object_p (bfd *abfd)
362 /* Set the right machine number for an Alpha ELF file. */
363 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
366 /* A relocation function which doesn't do anything. */
368 static bfd_reloc_status_type
369 elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
370 asymbol *sym ATTRIBUTE_UNUSED,
371 void * data ATTRIBUTE_UNUSED, asection *sec,
372 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
375 reloc->address += sec->output_offset;
379 /* A relocation function used for an unsupported reloc. */
381 static bfd_reloc_status_type
382 elf64_alpha_reloc_bad (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
383 asymbol *sym ATTRIBUTE_UNUSED,
384 void * data ATTRIBUTE_UNUSED, asection *sec,
385 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
388 reloc->address += sec->output_offset;
389 return bfd_reloc_notsupported;
392 /* Do the work of the GPDISP relocation. */
394 static bfd_reloc_status_type
395 elf64_alpha_do_reloc_gpdisp (bfd *abfd, bfd_vma gpdisp, bfd_byte *p_ldah,
398 bfd_reloc_status_type ret = bfd_reloc_ok;
400 unsigned long i_ldah, i_lda;
402 i_ldah = bfd_get_32 (abfd, p_ldah);
403 i_lda = bfd_get_32 (abfd, p_lda);
405 /* Complain if the instructions are not correct. */
406 if (((i_ldah >> 26) & 0x3f) != 0x09
407 || ((i_lda >> 26) & 0x3f) != 0x08)
408 ret = bfd_reloc_dangerous;
410 /* Extract the user-supplied offset, mirroring the sign extensions
411 that the instructions perform. */
412 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
413 addend = (addend ^ 0x80008000) - 0x80008000;
417 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
418 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
419 ret = bfd_reloc_overflow;
421 /* compensate for the sign extension again. */
422 i_ldah = ((i_ldah & 0xffff0000)
423 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
424 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
426 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
427 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
432 /* The special function for the GPDISP reloc. */
434 static bfd_reloc_status_type
435 elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry,
436 asymbol *sym ATTRIBUTE_UNUSED, void * data,
437 asection *input_section, bfd *output_bfd,
440 bfd_reloc_status_type ret;
441 bfd_vma gp, relocation;
442 bfd_vma high_address;
443 bfd_byte *p_ldah, *p_lda;
445 /* Don't do anything if we're not doing a final link. */
448 reloc_entry->address += input_section->output_offset;
452 high_address = bfd_get_section_limit (abfd, input_section);
453 if (reloc_entry->address > high_address
454 || reloc_entry->address + reloc_entry->addend > high_address)
455 return bfd_reloc_outofrange;
457 /* The gp used in the portion of the output object to which this
458 input object belongs is cached on the input bfd. */
459 gp = _bfd_get_gp_value (abfd);
461 relocation = (input_section->output_section->vma
462 + input_section->output_offset
463 + reloc_entry->address);
465 p_ldah = (bfd_byte *) data + reloc_entry->address;
466 p_lda = p_ldah + reloc_entry->addend;
468 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
470 /* Complain if the instructions are not correct. */
471 if (ret == bfd_reloc_dangerous)
472 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
477 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
478 from smaller values. Start with zero, widen, *then* decrement. */
479 #define MINUS_ONE (((bfd_vma)0) - 1)
482 #define SKIP_HOWTO(N) \
483 HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
485 static reloc_howto_type elf64_alpha_howto_table[] =
487 HOWTO (R_ALPHA_NONE, /* type */
489 0, /* size (0 = byte, 1 = short, 2 = long) */
491 TRUE, /* pc_relative */
493 complain_overflow_dont, /* complain_on_overflow */
494 elf64_alpha_reloc_nil, /* special_function */
496 FALSE, /* partial_inplace */
499 TRUE), /* pcrel_offset */
501 /* A 32 bit reference to a symbol. */
502 HOWTO (R_ALPHA_REFLONG, /* type */
504 2, /* size (0 = byte, 1 = short, 2 = long) */
506 FALSE, /* pc_relative */
508 complain_overflow_bitfield, /* complain_on_overflow */
509 bfd_elf_generic_reloc, /* special_function */
510 "REFLONG", /* name */
511 FALSE, /* partial_inplace */
512 0xffffffff, /* src_mask */
513 0xffffffff, /* dst_mask */
514 FALSE), /* pcrel_offset */
516 /* A 64 bit reference to a symbol. */
517 HOWTO (R_ALPHA_REFQUAD, /* type */
519 4, /* size (0 = byte, 1 = short, 2 = long) */
521 FALSE, /* pc_relative */
523 complain_overflow_bitfield, /* complain_on_overflow */
524 bfd_elf_generic_reloc, /* special_function */
525 "REFQUAD", /* name */
526 FALSE, /* partial_inplace */
527 MINUS_ONE, /* src_mask */
528 MINUS_ONE, /* dst_mask */
529 FALSE), /* pcrel_offset */
531 /* A 32 bit GP relative offset. This is just like REFLONG except
532 that when the value is used the value of the gp register will be
534 HOWTO (R_ALPHA_GPREL32, /* type */
536 2, /* size (0 = byte, 1 = short, 2 = long) */
538 FALSE, /* pc_relative */
540 complain_overflow_bitfield, /* complain_on_overflow */
541 bfd_elf_generic_reloc, /* special_function */
542 "GPREL32", /* name */
543 FALSE, /* partial_inplace */
544 0xffffffff, /* src_mask */
545 0xffffffff, /* dst_mask */
546 FALSE), /* pcrel_offset */
548 /* Used for an instruction that refers to memory off the GP register. */
549 HOWTO (R_ALPHA_LITERAL, /* type */
551 1, /* size (0 = byte, 1 = short, 2 = long) */
553 FALSE, /* pc_relative */
555 complain_overflow_signed, /* complain_on_overflow */
556 bfd_elf_generic_reloc, /* special_function */
557 "ELF_LITERAL", /* name */
558 FALSE, /* partial_inplace */
559 0xffff, /* src_mask */
560 0xffff, /* dst_mask */
561 FALSE), /* pcrel_offset */
563 /* This reloc only appears immediately following an ELF_LITERAL reloc.
564 It identifies a use of the literal. The symbol index is special:
565 1 means the literal address is in the base register of a memory
566 format instruction; 2 means the literal address is in the byte
567 offset register of a byte-manipulation instruction; 3 means the
568 literal address is in the target register of a jsr instruction.
569 This does not actually do any relocation. */
570 HOWTO (R_ALPHA_LITUSE, /* type */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
574 FALSE, /* pc_relative */
576 complain_overflow_dont, /* complain_on_overflow */
577 elf64_alpha_reloc_nil, /* special_function */
579 FALSE, /* partial_inplace */
582 FALSE), /* pcrel_offset */
584 /* Load the gp register. This is always used for a ldah instruction
585 which loads the upper 16 bits of the gp register. The symbol
586 index of the GPDISP instruction is an offset in bytes to the lda
587 instruction that loads the lower 16 bits. The value to use for
588 the relocation is the difference between the GP value and the
589 current location; the load will always be done against a register
590 holding the current address.
592 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
593 any offset is present in the instructions, it is an offset from
594 the register to the ldah instruction. This lets us avoid any
595 stupid hackery like inventing a gp value to do partial relocation
596 against. Also unlike ECOFF, we do the whole relocation off of
597 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
598 space consuming bit, that, since all the information was present
599 in the GPDISP_HI16 reloc. */
600 HOWTO (R_ALPHA_GPDISP, /* type */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
604 FALSE, /* pc_relative */
606 complain_overflow_dont, /* complain_on_overflow */
607 elf64_alpha_reloc_gpdisp, /* special_function */
609 FALSE, /* partial_inplace */
610 0xffff, /* src_mask */
611 0xffff, /* dst_mask */
612 TRUE), /* pcrel_offset */
614 /* A 21 bit branch. */
615 HOWTO (R_ALPHA_BRADDR, /* type */
617 2, /* size (0 = byte, 1 = short, 2 = long) */
619 TRUE, /* pc_relative */
621 complain_overflow_signed, /* complain_on_overflow */
622 bfd_elf_generic_reloc, /* special_function */
624 FALSE, /* partial_inplace */
625 0x1fffff, /* src_mask */
626 0x1fffff, /* dst_mask */
627 TRUE), /* pcrel_offset */
629 /* A hint for a jump to a register. */
630 HOWTO (R_ALPHA_HINT, /* type */
632 1, /* size (0 = byte, 1 = short, 2 = long) */
634 TRUE, /* pc_relative */
636 complain_overflow_dont, /* complain_on_overflow */
637 bfd_elf_generic_reloc, /* special_function */
639 FALSE, /* partial_inplace */
640 0x3fff, /* src_mask */
641 0x3fff, /* dst_mask */
642 TRUE), /* pcrel_offset */
644 /* 16 bit PC relative offset. */
645 HOWTO (R_ALPHA_SREL16, /* type */
647 1, /* size (0 = byte, 1 = short, 2 = long) */
649 TRUE, /* pc_relative */
651 complain_overflow_signed, /* complain_on_overflow */
652 bfd_elf_generic_reloc, /* special_function */
654 FALSE, /* partial_inplace */
655 0xffff, /* src_mask */
656 0xffff, /* dst_mask */
657 TRUE), /* pcrel_offset */
659 /* 32 bit PC relative offset. */
660 HOWTO (R_ALPHA_SREL32, /* type */
662 2, /* size (0 = byte, 1 = short, 2 = long) */
664 TRUE, /* pc_relative */
666 complain_overflow_signed, /* complain_on_overflow */
667 bfd_elf_generic_reloc, /* special_function */
669 FALSE, /* partial_inplace */
670 0xffffffff, /* src_mask */
671 0xffffffff, /* dst_mask */
672 TRUE), /* pcrel_offset */
674 /* A 64 bit PC relative offset. */
675 HOWTO (R_ALPHA_SREL64, /* type */
677 4, /* size (0 = byte, 1 = short, 2 = long) */
679 TRUE, /* pc_relative */
681 complain_overflow_signed, /* complain_on_overflow */
682 bfd_elf_generic_reloc, /* special_function */
684 FALSE, /* partial_inplace */
685 MINUS_ONE, /* src_mask */
686 MINUS_ONE, /* dst_mask */
687 TRUE), /* pcrel_offset */
689 /* Skip 12 - 16; deprecated ECOFF relocs. */
696 /* The high 16 bits of the displacement from GP to the target. */
697 HOWTO (R_ALPHA_GPRELHIGH,
699 1, /* size (0 = byte, 1 = short, 2 = long) */
701 FALSE, /* pc_relative */
703 complain_overflow_signed, /* complain_on_overflow */
704 bfd_elf_generic_reloc, /* special_function */
705 "GPRELHIGH", /* name */
706 FALSE, /* partial_inplace */
707 0xffff, /* src_mask */
708 0xffff, /* dst_mask */
709 FALSE), /* pcrel_offset */
711 /* The low 16 bits of the displacement from GP to the target. */
712 HOWTO (R_ALPHA_GPRELLOW,
714 1, /* size (0 = byte, 1 = short, 2 = long) */
716 FALSE, /* pc_relative */
718 complain_overflow_dont, /* complain_on_overflow */
719 bfd_elf_generic_reloc, /* special_function */
720 "GPRELLOW", /* name */
721 FALSE, /* partial_inplace */
722 0xffff, /* src_mask */
723 0xffff, /* dst_mask */
724 FALSE), /* pcrel_offset */
726 /* A 16-bit displacement from the GP to the target. */
727 HOWTO (R_ALPHA_GPREL16,
729 1, /* size (0 = byte, 1 = short, 2 = long) */
731 FALSE, /* pc_relative */
733 complain_overflow_signed, /* complain_on_overflow */
734 bfd_elf_generic_reloc, /* special_function */
735 "GPREL16", /* name */
736 FALSE, /* partial_inplace */
737 0xffff, /* src_mask */
738 0xffff, /* dst_mask */
739 FALSE), /* pcrel_offset */
741 /* Skip 20 - 23; deprecated ECOFF relocs. */
747 /* Misc ELF relocations. */
749 /* A dynamic relocation to copy the target into our .dynbss section. */
750 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
751 is present because every other ELF has one, but should not be used
752 because .dynbss is an ugly thing. */
759 complain_overflow_dont,
760 bfd_elf_generic_reloc,
767 /* A dynamic relocation for a .got entry. */
768 HOWTO (R_ALPHA_GLOB_DAT,
774 complain_overflow_dont,
775 bfd_elf_generic_reloc,
782 /* A dynamic relocation for a .plt entry. */
783 HOWTO (R_ALPHA_JMP_SLOT,
789 complain_overflow_dont,
790 bfd_elf_generic_reloc,
797 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
798 HOWTO (R_ALPHA_RELATIVE,
804 complain_overflow_dont,
805 bfd_elf_generic_reloc,
812 /* A 21 bit branch that adjusts for gp loads. */
813 HOWTO (R_ALPHA_BRSGP, /* type */
815 2, /* size (0 = byte, 1 = short, 2 = long) */
817 TRUE, /* pc_relative */
819 complain_overflow_signed, /* complain_on_overflow */
820 bfd_elf_generic_reloc, /* special_function */
822 FALSE, /* partial_inplace */
823 0x1fffff, /* src_mask */
824 0x1fffff, /* dst_mask */
825 TRUE), /* pcrel_offset */
827 /* Creates a tls_index for the symbol in the got. */
828 HOWTO (R_ALPHA_TLSGD, /* type */
830 1, /* size (0 = byte, 1 = short, 2 = long) */
832 FALSE, /* pc_relative */
834 complain_overflow_signed, /* complain_on_overflow */
835 bfd_elf_generic_reloc, /* special_function */
837 FALSE, /* partial_inplace */
838 0xffff, /* src_mask */
839 0xffff, /* dst_mask */
840 FALSE), /* pcrel_offset */
842 /* Creates a tls_index for the (current) module in the got. */
843 HOWTO (R_ALPHA_TLSLDM, /* type */
845 1, /* size (0 = byte, 1 = short, 2 = long) */
847 FALSE, /* pc_relative */
849 complain_overflow_signed, /* complain_on_overflow */
850 bfd_elf_generic_reloc, /* special_function */
852 FALSE, /* partial_inplace */
853 0xffff, /* src_mask */
854 0xffff, /* dst_mask */
855 FALSE), /* pcrel_offset */
857 /* A dynamic relocation for a DTP module entry. */
858 HOWTO (R_ALPHA_DTPMOD64, /* type */
860 4, /* size (0 = byte, 1 = short, 2 = long) */
862 FALSE, /* pc_relative */
864 complain_overflow_bitfield, /* complain_on_overflow */
865 bfd_elf_generic_reloc, /* special_function */
866 "DTPMOD64", /* name */
867 FALSE, /* partial_inplace */
868 MINUS_ONE, /* src_mask */
869 MINUS_ONE, /* dst_mask */
870 FALSE), /* pcrel_offset */
872 /* Creates a 64-bit offset in the got for the displacement
873 from DTP to the target. */
874 HOWTO (R_ALPHA_GOTDTPREL, /* type */
876 1, /* size (0 = byte, 1 = short, 2 = long) */
878 FALSE, /* pc_relative */
880 complain_overflow_signed, /* complain_on_overflow */
881 bfd_elf_generic_reloc, /* special_function */
882 "GOTDTPREL", /* name */
883 FALSE, /* partial_inplace */
884 0xffff, /* src_mask */
885 0xffff, /* dst_mask */
886 FALSE), /* pcrel_offset */
888 /* A dynamic relocation for a displacement from DTP to the target. */
889 HOWTO (R_ALPHA_DTPREL64, /* type */
891 4, /* size (0 = byte, 1 = short, 2 = long) */
893 FALSE, /* pc_relative */
895 complain_overflow_bitfield, /* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "DTPREL64", /* name */
898 FALSE, /* partial_inplace */
899 MINUS_ONE, /* src_mask */
900 MINUS_ONE, /* dst_mask */
901 FALSE), /* pcrel_offset */
903 /* The high 16 bits of the displacement from DTP to the target. */
904 HOWTO (R_ALPHA_DTPRELHI, /* type */
906 1, /* size (0 = byte, 1 = short, 2 = long) */
908 FALSE, /* pc_relative */
910 complain_overflow_signed, /* complain_on_overflow */
911 bfd_elf_generic_reloc, /* special_function */
912 "DTPRELHI", /* name */
913 FALSE, /* partial_inplace */
914 0xffff, /* src_mask */
915 0xffff, /* dst_mask */
916 FALSE), /* pcrel_offset */
918 /* The low 16 bits of the displacement from DTP to the target. */
919 HOWTO (R_ALPHA_DTPRELLO, /* type */
921 1, /* size (0 = byte, 1 = short, 2 = long) */
923 FALSE, /* pc_relative */
925 complain_overflow_dont, /* complain_on_overflow */
926 bfd_elf_generic_reloc, /* special_function */
927 "DTPRELLO", /* name */
928 FALSE, /* partial_inplace */
929 0xffff, /* src_mask */
930 0xffff, /* dst_mask */
931 FALSE), /* pcrel_offset */
933 /* A 16-bit displacement from DTP to the target. */
934 HOWTO (R_ALPHA_DTPREL16, /* type */
936 1, /* size (0 = byte, 1 = short, 2 = long) */
938 FALSE, /* pc_relative */
940 complain_overflow_signed, /* complain_on_overflow */
941 bfd_elf_generic_reloc, /* special_function */
942 "DTPREL16", /* name */
943 FALSE, /* partial_inplace */
944 0xffff, /* src_mask */
945 0xffff, /* dst_mask */
946 FALSE), /* pcrel_offset */
948 /* Creates a 64-bit offset in the got for the displacement
949 from TP to the target. */
950 HOWTO (R_ALPHA_GOTTPREL, /* type */
952 1, /* size (0 = byte, 1 = short, 2 = long) */
954 FALSE, /* pc_relative */
956 complain_overflow_signed, /* complain_on_overflow */
957 bfd_elf_generic_reloc, /* special_function */
958 "GOTTPREL", /* name */
959 FALSE, /* partial_inplace */
960 0xffff, /* src_mask */
961 0xffff, /* dst_mask */
962 FALSE), /* pcrel_offset */
964 /* A dynamic relocation for a displacement from TP to the target. */
965 HOWTO (R_ALPHA_TPREL64, /* type */
967 4, /* size (0 = byte, 1 = short, 2 = long) */
969 FALSE, /* pc_relative */
971 complain_overflow_bitfield, /* complain_on_overflow */
972 bfd_elf_generic_reloc, /* special_function */
973 "TPREL64", /* name */
974 FALSE, /* partial_inplace */
975 MINUS_ONE, /* src_mask */
976 MINUS_ONE, /* dst_mask */
977 FALSE), /* pcrel_offset */
979 /* The high 16 bits of the displacement from TP to the target. */
980 HOWTO (R_ALPHA_TPRELHI, /* type */
982 1, /* size (0 = byte, 1 = short, 2 = long) */
984 FALSE, /* pc_relative */
986 complain_overflow_signed, /* complain_on_overflow */
987 bfd_elf_generic_reloc, /* special_function */
988 "TPRELHI", /* name */
989 FALSE, /* partial_inplace */
990 0xffff, /* src_mask */
991 0xffff, /* dst_mask */
992 FALSE), /* pcrel_offset */
994 /* The low 16 bits of the displacement from TP to the target. */
995 HOWTO (R_ALPHA_TPRELLO, /* type */
997 1, /* size (0 = byte, 1 = short, 2 = long) */
999 FALSE, /* pc_relative */
1001 complain_overflow_dont, /* complain_on_overflow */
1002 bfd_elf_generic_reloc, /* special_function */
1003 "TPRELLO", /* name */
1004 FALSE, /* partial_inplace */
1005 0xffff, /* src_mask */
1006 0xffff, /* dst_mask */
1007 FALSE), /* pcrel_offset */
1009 /* A 16-bit displacement from TP to the target. */
1010 HOWTO (R_ALPHA_TPREL16, /* type */
1012 1, /* size (0 = byte, 1 = short, 2 = long) */
1014 FALSE, /* pc_relative */
1016 complain_overflow_signed, /* complain_on_overflow */
1017 bfd_elf_generic_reloc, /* special_function */
1018 "TPREL16", /* name */
1019 FALSE, /* partial_inplace */
1020 0xffff, /* src_mask */
1021 0xffff, /* dst_mask */
1022 FALSE), /* pcrel_offset */
1025 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1027 struct elf_reloc_map
1029 bfd_reloc_code_real_type bfd_reloc_val;
1033 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1035 {BFD_RELOC_NONE, R_ALPHA_NONE},
1036 {BFD_RELOC_32, R_ALPHA_REFLONG},
1037 {BFD_RELOC_64, R_ALPHA_REFQUAD},
1038 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
1039 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
1040 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
1041 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
1042 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
1043 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
1044 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
1045 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
1046 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
1047 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
1048 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
1049 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
1050 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
1051 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
1052 {BFD_RELOC_ALPHA_TLSGD, R_ALPHA_TLSGD},
1053 {BFD_RELOC_ALPHA_TLSLDM, R_ALPHA_TLSLDM},
1054 {BFD_RELOC_ALPHA_DTPMOD64, R_ALPHA_DTPMOD64},
1055 {BFD_RELOC_ALPHA_GOTDTPREL16, R_ALPHA_GOTDTPREL},
1056 {BFD_RELOC_ALPHA_DTPREL64, R_ALPHA_DTPREL64},
1057 {BFD_RELOC_ALPHA_DTPREL_HI16, R_ALPHA_DTPRELHI},
1058 {BFD_RELOC_ALPHA_DTPREL_LO16, R_ALPHA_DTPRELLO},
1059 {BFD_RELOC_ALPHA_DTPREL16, R_ALPHA_DTPREL16},
1060 {BFD_RELOC_ALPHA_GOTTPREL16, R_ALPHA_GOTTPREL},
1061 {BFD_RELOC_ALPHA_TPREL64, R_ALPHA_TPREL64},
1062 {BFD_RELOC_ALPHA_TPREL_HI16, R_ALPHA_TPRELHI},
1063 {BFD_RELOC_ALPHA_TPREL_LO16, R_ALPHA_TPRELLO},
1064 {BFD_RELOC_ALPHA_TPREL16, R_ALPHA_TPREL16},
1067 /* Given a BFD reloc type, return a HOWTO structure. */
1069 static reloc_howto_type *
1070 elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1071 bfd_reloc_code_real_type code)
1073 const struct elf_reloc_map *i, *e;
1074 i = e = elf64_alpha_reloc_map;
1075 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1078 if (i->bfd_reloc_val == code)
1079 return &elf64_alpha_howto_table[i->elf_reloc_val];
1084 static reloc_howto_type *
1085 elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1091 i < (sizeof (elf64_alpha_howto_table)
1092 / sizeof (elf64_alpha_howto_table[0]));
1094 if (elf64_alpha_howto_table[i].name != NULL
1095 && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0)
1096 return &elf64_alpha_howto_table[i];
1101 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1104 elf64_alpha_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1105 Elf_Internal_Rela *dst)
1107 unsigned r_type = ELF64_R_TYPE(dst->r_info);
1108 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
1109 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1112 /* These two relocations create a two-word entry in the got. */
1113 #define alpha_got_entry_size(r_type) \
1114 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1116 /* This is PT_TLS segment p_vaddr. */
1117 #define alpha_get_dtprel_base(info) \
1118 (elf_hash_table (info)->tls_sec->vma)
1120 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1121 is assigned offset round(16, PT_TLS p_align). */
1122 #define alpha_get_tprel_base(info) \
1123 (elf_hash_table (info)->tls_sec->vma \
1124 - align_power ((bfd_vma) 16, \
1125 elf_hash_table (info)->tls_sec->alignment_power))
1127 /* Handle an Alpha specific section when reading an object file. This
1128 is called when bfd_section_from_shdr finds a section with an unknown
1130 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1134 elf64_alpha_section_from_shdr (bfd *abfd,
1135 Elf_Internal_Shdr *hdr,
1141 /* There ought to be a place to keep ELF backend specific flags, but
1142 at the moment there isn't one. We just keep track of the
1143 sections by their name, instead. Fortunately, the ABI gives
1144 suggested names for all the MIPS specific sections, so we will
1145 probably get away with this. */
1146 switch (hdr->sh_type)
1148 case SHT_ALPHA_DEBUG:
1149 if (strcmp (name, ".mdebug") != 0)
1156 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1158 newsect = hdr->bfd_section;
1160 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1162 if (! bfd_set_section_flags (abfd, newsect,
1163 (bfd_get_section_flags (abfd, newsect)
1171 /* Convert Alpha specific section flags to bfd internal section flags. */
1174 elf64_alpha_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
1176 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1177 *flags |= SEC_SMALL_DATA;
1182 /* Set the correct type for an Alpha ELF section. We do this by the
1183 section name, which is a hack, but ought to work. */
1186 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1188 register const char *name;
1190 name = bfd_get_section_name (abfd, sec);
1192 if (strcmp (name, ".mdebug") == 0)
1194 hdr->sh_type = SHT_ALPHA_DEBUG;
1195 /* In a shared object on Irix 5.3, the .mdebug section has an
1196 entsize of 0. FIXME: Does this matter? */
1197 if ((abfd->flags & DYNAMIC) != 0 )
1198 hdr->sh_entsize = 0;
1200 hdr->sh_entsize = 1;
1202 else if ((sec->flags & SEC_SMALL_DATA)
1203 || strcmp (name, ".sdata") == 0
1204 || strcmp (name, ".sbss") == 0
1205 || strcmp (name, ".lit4") == 0
1206 || strcmp (name, ".lit8") == 0)
1207 hdr->sh_flags |= SHF_ALPHA_GPREL;
1212 /* Hook called by the linker routine which adds symbols from an object
1213 file. We use it to put .comm items in .sbss, and not .bss. */
1216 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1217 Elf_Internal_Sym *sym,
1218 const char **namep ATTRIBUTE_UNUSED,
1219 flagword *flagsp ATTRIBUTE_UNUSED,
1220 asection **secp, bfd_vma *valp)
1222 if (sym->st_shndx == SHN_COMMON
1223 && !info->relocatable
1224 && sym->st_size <= elf_gp_size (abfd))
1226 /* Common symbols less than or equal to -G nn bytes are
1227 automatically put into .sbss. */
1229 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1233 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1236 | SEC_LINKER_CREATED));
1242 *valp = sym->st_size;
1248 /* Create the .got section. */
1251 elf64_alpha_create_got_section (bfd *abfd,
1252 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1257 if (! is_alpha_elf (abfd))
1260 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1261 | SEC_LINKER_CREATED);
1262 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1264 || !bfd_set_section_alignment (abfd, s, 3))
1267 alpha_elf_tdata (abfd)->got = s;
1269 /* Make sure the object's gotobj is set to itself so that we default
1270 to every object with its own .got. We'll merge .gots later once
1271 we've collected each object's info. */
1272 alpha_elf_tdata (abfd)->gotobj = abfd;
1277 /* Create all the dynamic sections. */
1280 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1284 struct elf_link_hash_entry *h;
1286 if (! is_alpha_elf (abfd))
1289 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1291 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1292 | SEC_LINKER_CREATED
1293 | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1294 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1295 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4))
1298 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1300 h = _bfd_elf_define_linkage_sym (abfd, info, s,
1301 "_PROCEDURE_LINKAGE_TABLE_");
1302 elf_hash_table (info)->hplt = h;
1306 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1307 | SEC_LINKER_CREATED | SEC_READONLY);
1308 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1309 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1312 if (elf64_alpha_use_secureplt)
1314 flags = SEC_ALLOC | SEC_LINKER_CREATED;
1315 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1316 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1320 /* We may or may not have created a .got section for this object, but
1321 we definitely havn't done the rest of the work. */
1323 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1325 if (!elf64_alpha_create_got_section (abfd, info))
1329 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1330 | SEC_LINKER_CREATED | SEC_READONLY);
1331 s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1333 || !bfd_set_section_alignment (abfd, s, 3))
1336 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1337 dynobj's .got section. We don't do this in the linker script
1338 because we don't want to define the symbol if we are not creating
1339 a global offset table. */
1340 h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1341 "_GLOBAL_OFFSET_TABLE_");
1342 elf_hash_table (info)->hgot = h;
1349 /* Read ECOFF debugging information from a .mdebug section into a
1350 ecoff_debug_info structure. */
1353 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1354 struct ecoff_debug_info *debug)
1357 const struct ecoff_debug_swap *swap;
1358 char *ext_hdr = NULL;
1360 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1361 memset (debug, 0, sizeof (*debug));
1363 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1364 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1367 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1368 swap->external_hdr_size))
1371 symhdr = &debug->symbolic_header;
1372 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1374 /* The symbolic header contains absolute file offsets and sizes to
1376 #define READ(ptr, offset, count, size, type) \
1377 if (symhdr->count == 0) \
1378 debug->ptr = NULL; \
1381 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1382 debug->ptr = (type) bfd_malloc (amt); \
1383 if (debug->ptr == NULL) \
1384 goto error_return; \
1385 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1386 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1387 goto error_return; \
1390 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1391 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1392 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1393 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1394 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1395 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1397 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1398 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1399 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1400 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1401 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1409 if (ext_hdr != NULL)
1411 if (debug->line != NULL)
1413 if (debug->external_dnr != NULL)
1414 free (debug->external_dnr);
1415 if (debug->external_pdr != NULL)
1416 free (debug->external_pdr);
1417 if (debug->external_sym != NULL)
1418 free (debug->external_sym);
1419 if (debug->external_opt != NULL)
1420 free (debug->external_opt);
1421 if (debug->external_aux != NULL)
1422 free (debug->external_aux);
1423 if (debug->ss != NULL)
1425 if (debug->ssext != NULL)
1426 free (debug->ssext);
1427 if (debug->external_fdr != NULL)
1428 free (debug->external_fdr);
1429 if (debug->external_rfd != NULL)
1430 free (debug->external_rfd);
1431 if (debug->external_ext != NULL)
1432 free (debug->external_ext);
1436 /* Alpha ELF local labels start with '$'. */
1439 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1441 return name[0] == '$';
1445 elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols,
1446 bfd_vma offset, const char **filename_ptr,
1447 const char **functionname_ptr,
1448 unsigned int *line_ptr)
1452 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
1453 section, symbols, offset,
1454 filename_ptr, functionname_ptr,
1456 &elf_tdata (abfd)->dwarf2_find_line_info))
1459 msec = bfd_get_section_by_name (abfd, ".mdebug");
1463 struct alpha_elf_find_line *fi;
1464 const struct ecoff_debug_swap * const swap =
1465 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1467 /* If we are called during a link, alpha_elf_final_link may have
1468 cleared the SEC_HAS_CONTENTS field. We force it back on here
1469 if appropriate (which it normally will be). */
1470 origflags = msec->flags;
1471 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1472 msec->flags |= SEC_HAS_CONTENTS;
1474 fi = alpha_elf_tdata (abfd)->find_line_info;
1477 bfd_size_type external_fdr_size;
1480 struct fdr *fdr_ptr;
1481 bfd_size_type amt = sizeof (struct alpha_elf_find_line);
1483 fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt);
1486 msec->flags = origflags;
1490 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1492 msec->flags = origflags;
1496 /* Swap in the FDR information. */
1497 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1498 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1499 if (fi->d.fdr == NULL)
1501 msec->flags = origflags;
1504 external_fdr_size = swap->external_fdr_size;
1505 fdr_ptr = fi->d.fdr;
1506 fraw_src = (char *) fi->d.external_fdr;
1507 fraw_end = (fraw_src
1508 + fi->d.symbolic_header.ifdMax * external_fdr_size);
1509 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1510 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
1512 alpha_elf_tdata (abfd)->find_line_info = fi;
1514 /* Note that we don't bother to ever free this information.
1515 find_nearest_line is either called all the time, as in
1516 objdump -l, so the information should be saved, or it is
1517 rarely called, as in ld error messages, so the memory
1518 wasted is unimportant. Still, it would probably be a
1519 good idea for free_cached_info to throw it away. */
1522 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1523 &fi->i, filename_ptr, functionname_ptr,
1526 msec->flags = origflags;
1530 msec->flags = origflags;
1533 /* Fall back on the generic ELF find_nearest_line routine. */
1535 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
1536 filename_ptr, functionname_ptr,
1540 /* Structure used to pass information to alpha_elf_output_extsym. */
1545 struct bfd_link_info *info;
1546 struct ecoff_debug_info *debug;
1547 const struct ecoff_debug_swap *swap;
1552 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
1554 struct extsym_info *einfo = (struct extsym_info *) data;
1556 asection *sec, *output_section;
1558 if (h->root.indx == -2)
1560 else if ((h->root.def_dynamic
1561 || h->root.ref_dynamic
1562 || h->root.root.type == bfd_link_hash_new)
1563 && !h->root.def_regular
1564 && !h->root.ref_regular)
1566 else if (einfo->info->strip == strip_all
1567 || (einfo->info->strip == strip_some
1568 && bfd_hash_lookup (einfo->info->keep_hash,
1569 h->root.root.root.string,
1570 FALSE, FALSE) == NULL))
1578 if (h->esym.ifd == -2)
1581 h->esym.cobol_main = 0;
1582 h->esym.weakext = 0;
1583 h->esym.reserved = 0;
1584 h->esym.ifd = ifdNil;
1585 h->esym.asym.value = 0;
1586 h->esym.asym.st = stGlobal;
1588 if (h->root.root.type != bfd_link_hash_defined
1589 && h->root.root.type != bfd_link_hash_defweak)
1590 h->esym.asym.sc = scAbs;
1595 sec = h->root.root.u.def.section;
1596 output_section = sec->output_section;
1598 /* When making a shared library and symbol h is the one from
1599 the another shared library, OUTPUT_SECTION may be null. */
1600 if (output_section == NULL)
1601 h->esym.asym.sc = scUndefined;
1604 name = bfd_section_name (output_section->owner, output_section);
1606 if (strcmp (name, ".text") == 0)
1607 h->esym.asym.sc = scText;
1608 else if (strcmp (name, ".data") == 0)
1609 h->esym.asym.sc = scData;
1610 else if (strcmp (name, ".sdata") == 0)
1611 h->esym.asym.sc = scSData;
1612 else if (strcmp (name, ".rodata") == 0
1613 || strcmp (name, ".rdata") == 0)
1614 h->esym.asym.sc = scRData;
1615 else if (strcmp (name, ".bss") == 0)
1616 h->esym.asym.sc = scBss;
1617 else if (strcmp (name, ".sbss") == 0)
1618 h->esym.asym.sc = scSBss;
1619 else if (strcmp (name, ".init") == 0)
1620 h->esym.asym.sc = scInit;
1621 else if (strcmp (name, ".fini") == 0)
1622 h->esym.asym.sc = scFini;
1624 h->esym.asym.sc = scAbs;
1628 h->esym.asym.reserved = 0;
1629 h->esym.asym.index = indexNil;
1632 if (h->root.root.type == bfd_link_hash_common)
1633 h->esym.asym.value = h->root.root.u.c.size;
1634 else if (h->root.root.type == bfd_link_hash_defined
1635 || h->root.root.type == bfd_link_hash_defweak)
1637 if (h->esym.asym.sc == scCommon)
1638 h->esym.asym.sc = scBss;
1639 else if (h->esym.asym.sc == scSCommon)
1640 h->esym.asym.sc = scSBss;
1642 sec = h->root.root.u.def.section;
1643 output_section = sec->output_section;
1644 if (output_section != NULL)
1645 h->esym.asym.value = (h->root.root.u.def.value
1646 + sec->output_offset
1647 + output_section->vma);
1649 h->esym.asym.value = 0;
1652 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1653 h->root.root.root.string,
1656 einfo->failed = TRUE;
1663 /* Search for and possibly create a got entry. */
1665 static struct alpha_elf_got_entry *
1666 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1667 unsigned long r_type, unsigned long r_symndx,
1670 struct alpha_elf_got_entry *gotent;
1671 struct alpha_elf_got_entry **slot;
1674 slot = &h->got_entries;
1677 /* This is a local .got entry -- record for merge. */
1679 struct alpha_elf_got_entry **local_got_entries;
1681 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1682 if (!local_got_entries)
1685 Elf_Internal_Shdr *symtab_hdr;
1687 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1688 size = symtab_hdr->sh_info;
1689 size *= sizeof (struct alpha_elf_got_entry *);
1692 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1693 if (!local_got_entries)
1696 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1699 slot = &local_got_entries[r_symndx];
1702 for (gotent = *slot; gotent ; gotent = gotent->next)
1703 if (gotent->gotobj == abfd
1704 && gotent->reloc_type == r_type
1705 && gotent->addend == r_addend)
1713 amt = sizeof (struct alpha_elf_got_entry);
1714 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1718 gotent->gotobj = abfd;
1719 gotent->addend = r_addend;
1720 gotent->got_offset = -1;
1721 gotent->plt_offset = -1;
1722 gotent->use_count = 1;
1723 gotent->reloc_type = r_type;
1724 gotent->reloc_done = 0;
1725 gotent->reloc_xlated = 0;
1727 gotent->next = *slot;
1730 entry_size = alpha_got_entry_size (r_type);
1731 alpha_elf_tdata (abfd)->total_got_size += entry_size;
1733 alpha_elf_tdata(abfd)->local_got_size += entry_size;
1736 gotent->use_count += 1;
1742 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1744 return ((ah->root.type == STT_FUNC
1745 || ah->root.root.type == bfd_link_hash_undefweak
1746 || ah->root.root.type == bfd_link_hash_undefined)
1747 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1748 && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1751 /* Handle dynamic relocations when doing an Alpha ELF link. */
1754 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1755 asection *sec, const Elf_Internal_Rela *relocs)
1759 Elf_Internal_Shdr *symtab_hdr;
1760 struct alpha_elf_link_hash_entry **sym_hashes;
1761 const Elf_Internal_Rela *rel, *relend;
1764 if (info->relocatable)
1767 /* Don't do anything special with non-loaded, non-alloced sections.
1768 In particular, any relocs in such sections should not affect GOT
1769 and PLT reference counting (ie. we don't allow them to create GOT
1770 or PLT entries), there's no possibility or desire to optimize TLS
1771 relocs, and there's not much point in propagating relocs to shared
1772 libs that the dynamic linker won't relocate. */
1773 if ((sec->flags & SEC_ALLOC) == 0)
1776 BFD_ASSERT (is_alpha_elf (abfd));
1778 dynobj = elf_hash_table (info)->dynobj;
1780 elf_hash_table (info)->dynobj = dynobj = abfd;
1783 symtab_hdr = &elf_symtab_hdr (abfd);
1784 sym_hashes = alpha_elf_sym_hashes (abfd);
1786 relend = relocs + sec->reloc_count;
1787 for (rel = relocs; rel < relend; ++rel)
1795 unsigned long r_symndx, r_type;
1796 struct alpha_elf_link_hash_entry *h;
1797 unsigned int gotent_flags;
1798 bfd_boolean maybe_dynamic;
1802 r_symndx = ELF64_R_SYM (rel->r_info);
1803 if (r_symndx < symtab_hdr->sh_info)
1807 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1809 while (h->root.root.type == bfd_link_hash_indirect
1810 || h->root.root.type == bfd_link_hash_warning)
1811 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1813 /* PR15323, ref flags aren't set for references in the same
1815 h->root.root.non_ir_ref = 1;
1816 h->root.ref_regular = 1;
1819 /* We can only get preliminary data on whether a symbol is
1820 locally or externally defined, as not all of the input files
1821 have yet been processed. Do something with what we know, as
1822 this may help reduce memory usage and processing time later. */
1823 maybe_dynamic = FALSE;
1824 if (h && ((info->shared
1826 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1827 || !h->root.def_regular
1828 || h->root.root.type == bfd_link_hash_defweak))
1829 maybe_dynamic = TRUE;
1833 r_type = ELF64_R_TYPE (rel->r_info);
1834 addend = rel->r_addend;
1838 case R_ALPHA_LITERAL:
1839 need = NEED_GOT | NEED_GOT_ENTRY;
1841 /* Remember how this literal is used from its LITUSEs.
1842 This will be important when it comes to decide if we can
1843 create a .plt entry for a function symbol. */
1844 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
1845 if (rel->r_addend >= 1 && rel->r_addend <= 6)
1846 gotent_flags |= 1 << rel->r_addend;
1849 /* No LITUSEs -- presumably the address is used somehow. */
1850 if (gotent_flags == 0)
1851 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
1854 case R_ALPHA_GPDISP:
1855 case R_ALPHA_GPREL16:
1856 case R_ALPHA_GPREL32:
1857 case R_ALPHA_GPRELHIGH:
1858 case R_ALPHA_GPRELLOW:
1863 case R_ALPHA_REFLONG:
1864 case R_ALPHA_REFQUAD:
1865 if (info->shared || maybe_dynamic)
1869 case R_ALPHA_TLSLDM:
1870 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1871 reloc to the STN_UNDEF (0) symbol so that they all match. */
1872 r_symndx = STN_UNDEF;
1874 maybe_dynamic = FALSE;
1878 case R_ALPHA_GOTDTPREL:
1879 need = NEED_GOT | NEED_GOT_ENTRY;
1882 case R_ALPHA_GOTTPREL:
1883 need = NEED_GOT | NEED_GOT_ENTRY;
1884 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
1886 info->flags |= DF_STATIC_TLS;
1889 case R_ALPHA_TPREL64:
1890 if (info->shared && !info->pie)
1892 info->flags |= DF_STATIC_TLS;
1895 else if (maybe_dynamic)
1900 if (need & NEED_GOT)
1902 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1904 if (!elf64_alpha_create_got_section (abfd, info))
1909 if (need & NEED_GOT_ENTRY)
1911 struct alpha_elf_got_entry *gotent;
1913 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
1919 gotent->flags |= gotent_flags;
1922 gotent_flags |= h->flags;
1923 h->flags = gotent_flags;
1925 /* Make a guess as to whether a .plt entry is needed. */
1926 /* ??? It appears that we won't make it into
1927 adjust_dynamic_symbol for symbols that remain
1928 totally undefined. Copying this check here means
1929 we can create a plt entry for them too. */
1931 = (maybe_dynamic && elf64_alpha_want_plt (h));
1936 if (need & NEED_DYNREL)
1938 /* We need to create the section here now whether we eventually
1939 use it or not so that it gets mapped to an output section by
1940 the linker. If not used, we'll kill it in size_dynamic_sections. */
1943 sreloc = _bfd_elf_make_dynamic_reloc_section
1944 (sec, dynobj, 3, abfd, /*rela?*/ TRUE);
1952 /* Since we havn't seen all of the input symbols yet, we
1953 don't know whether we'll actually need a dynamic relocation
1954 entry for this reloc. So make a record of it. Once we
1955 find out if this thing needs dynamic relocation we'll
1956 expand the relocation sections by the appropriate amount. */
1958 struct alpha_elf_reloc_entry *rent;
1960 for (rent = h->reloc_entries; rent; rent = rent->next)
1961 if (rent->rtype == r_type && rent->srel == sreloc)
1966 amt = sizeof (struct alpha_elf_reloc_entry);
1967 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
1971 rent->srel = sreloc;
1972 rent->rtype = r_type;
1974 rent->reltext = (sec->flags & SEC_READONLY) != 0;
1976 rent->next = h->reloc_entries;
1977 h->reloc_entries = rent;
1982 else if (info->shared)
1984 /* If this is a shared library, and the section is to be
1985 loaded into memory, we need a RELATIVE reloc. */
1986 sreloc->size += sizeof (Elf64_External_Rela);
1987 if (sec->flags & SEC_READONLY)
1988 info->flags |= DF_TEXTREL;
1996 /* Return the section that should be marked against GC for a given
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:
2014 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2017 /* Update the got entry reference counts for the section being removed. */
2020 elf64_alpha_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2021 asection *sec, const Elf_Internal_Rela *relocs)
2023 Elf_Internal_Shdr *symtab_hdr;
2024 struct alpha_elf_link_hash_entry **sym_hashes;
2025 const Elf_Internal_Rela *rel, *relend;
2027 if (info->relocatable)
2030 symtab_hdr = &elf_symtab_hdr (abfd);
2031 sym_hashes = alpha_elf_sym_hashes (abfd);
2033 relend = relocs + sec->reloc_count;
2034 for (rel = relocs; rel < relend; rel++)
2036 unsigned long r_symndx, r_type;
2037 struct alpha_elf_link_hash_entry *h = NULL;
2038 struct alpha_elf_got_entry *gotent;
2040 r_symndx = ELF64_R_SYM (rel->r_info);
2041 if (r_symndx >= symtab_hdr->sh_info)
2043 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2044 while (h->root.root.type == bfd_link_hash_indirect
2045 || h->root.root.type == bfd_link_hash_warning)
2046 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2049 r_type = ELF64_R_TYPE (rel->r_info);
2052 case R_ALPHA_LITERAL:
2053 /* ??? Ignore re-computation of gotent_flags. We're not
2054 carrying a use-count for each bit in that mask. */
2057 case R_ALPHA_GOTDTPREL:
2058 case R_ALPHA_GOTTPREL:
2059 /* Fetch the got entry from the tables. */
2060 gotent = get_got_entry (abfd, h, r_type, r_symndx, rel->r_addend);
2062 /* The got entry *must* exist, since we should have created it
2063 before during check_relocs. Also note that get_got_entry
2064 assumed this was going to be another use, and so incremented
2065 the use count again. Thus the use count must be at least the
2066 one real use and the "use" we just added. */
2067 if (gotent == NULL || gotent->use_count < 2)
2072 gotent->use_count -= 2;
2083 /* Adjust a symbol defined by a dynamic object and referenced by a
2084 regular object. The current definition is in some section of the
2085 dynamic object, but we're not including those sections. We have to
2086 change the definition to something the rest of the link can
2090 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2091 struct elf_link_hash_entry *h)
2095 struct alpha_elf_link_hash_entry *ah;
2097 dynobj = elf_hash_table(info)->dynobj;
2098 ah = (struct alpha_elf_link_hash_entry *)h;
2100 /* Now that we've seen all of the input symbols, finalize our decision
2101 about whether this symbol should get a .plt entry. Irritatingly, it
2102 is common for folk to leave undefined symbols in shared libraries,
2103 and they still expect lazy binding; accept undefined symbols in lieu
2105 if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2107 h->needs_plt = TRUE;
2109 s = bfd_get_linker_section (dynobj, ".plt");
2110 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2113 /* We need one plt entry per got subsection. Delay allocation of
2114 the actual plt entries until size_plt_section, called from
2115 size_dynamic_sections or during relaxation. */
2120 h->needs_plt = FALSE;
2122 /* If this is a weak symbol, and there is a real definition, the
2123 processor independent code will have arranged for us to see the
2124 real definition first, and we can just use the same value. */
2125 if (h->u.weakdef != NULL)
2127 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2128 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2129 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2130 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2134 /* This is a reference to a symbol defined by a dynamic object which
2135 is not a function. The Alpha, since it uses .got entries for all
2136 symbols even in regular objects, does not need the hackery of a
2137 .dynbss section and COPY dynamic relocations. */
2142 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2145 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2146 const Elf_Internal_Sym *isym,
2147 bfd_boolean definition,
2148 bfd_boolean dynamic)
2150 if (!dynamic && definition)
2151 h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2152 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
2155 /* Symbol versioning can create new symbols, and make our old symbols
2156 indirect to the new ones. Consolidate the got and reloc information
2157 in these situations. */
2160 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2161 struct elf_link_hash_entry *dir,
2162 struct elf_link_hash_entry *ind)
2164 struct alpha_elf_link_hash_entry *hi
2165 = (struct alpha_elf_link_hash_entry *) ind;
2166 struct alpha_elf_link_hash_entry *hs
2167 = (struct alpha_elf_link_hash_entry *) dir;
2169 /* Do the merging in the superclass. */
2170 _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2172 /* Merge the flags. Whee. */
2173 hs->flags |= hi->flags;
2175 /* ??? It's unclear to me what's really supposed to happen when
2176 "merging" defweak and defined symbols, given that we don't
2177 actually throw away the defweak. This more-or-less copies
2178 the logic related to got and plt entries in the superclass. */
2179 if (ind->root.type != bfd_link_hash_indirect)
2182 /* Merge the .got entries. Cannibalize the old symbol's list in
2183 doing so, since we don't need it anymore. */
2185 if (hs->got_entries == NULL)
2186 hs->got_entries = hi->got_entries;
2189 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2191 gsh = hs->got_entries;
2192 for (gi = hi->got_entries; gi ; gi = gin)
2195 for (gs = gsh; gs ; gs = gs->next)
2196 if (gi->gotobj == gs->gotobj
2197 && gi->reloc_type == gs->reloc_type
2198 && gi->addend == gs->addend)
2200 gi->use_count += gs->use_count;
2203 gi->next = hs->got_entries;
2204 hs->got_entries = gi;
2208 hi->got_entries = NULL;
2210 /* And similar for the reloc entries. */
2212 if (hs->reloc_entries == NULL)
2213 hs->reloc_entries = hi->reloc_entries;
2216 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2218 rsh = hs->reloc_entries;
2219 for (ri = hi->reloc_entries; ri ; ri = rin)
2222 for (rs = rsh; rs ; rs = rs->next)
2223 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2225 rs->count += ri->count;
2228 ri->next = hs->reloc_entries;
2229 hs->reloc_entries = ri;
2233 hi->reloc_entries = NULL;
2236 /* Is it possible to merge two object file's .got tables? */
2239 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2241 int total = alpha_elf_tdata (a)->total_got_size;
2244 /* Trivial quick fallout test. */
2245 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2248 /* By their nature, local .got entries cannot be merged. */
2249 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2252 /* Failing the common trivial comparison, we must effectively
2253 perform the merge. Not actually performing the merge means that
2254 we don't have to store undo information in case we fail. */
2255 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2257 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2258 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2261 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2262 for (i = 0; i < n; ++i)
2264 struct alpha_elf_got_entry *ae, *be;
2265 struct alpha_elf_link_hash_entry *h;
2268 while (h->root.root.type == bfd_link_hash_indirect
2269 || h->root.root.type == bfd_link_hash_warning)
2270 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2272 for (be = h->got_entries; be ; be = be->next)
2274 if (be->use_count == 0)
2276 if (be->gotobj != b)
2279 for (ae = h->got_entries; ae ; ae = ae->next)
2281 && ae->reloc_type == be->reloc_type
2282 && ae->addend == be->addend)
2285 total += alpha_got_entry_size (be->reloc_type);
2286 if (total > MAX_GOT_SIZE)
2296 /* Actually merge two .got tables. */
2299 elf64_alpha_merge_gots (bfd *a, bfd *b)
2301 int total = alpha_elf_tdata (a)->total_got_size;
2304 /* Remember local expansion. */
2306 int e = alpha_elf_tdata (b)->local_got_size;
2308 alpha_elf_tdata (a)->local_got_size += e;
2311 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2313 struct alpha_elf_got_entry **local_got_entries;
2314 struct alpha_elf_link_hash_entry **hashes;
2315 Elf_Internal_Shdr *symtab_hdr;
2318 /* Let the local .got entries know they are part of a new subsegment. */
2319 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2320 if (local_got_entries)
2322 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2323 for (i = 0; i < n; ++i)
2325 struct alpha_elf_got_entry *ent;
2326 for (ent = local_got_entries[i]; ent; ent = ent->next)
2331 /* Merge the global .got entries. */
2332 hashes = alpha_elf_sym_hashes (bsub);
2333 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2335 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2336 for (i = 0; i < n; ++i)
2338 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2339 struct alpha_elf_link_hash_entry *h;
2342 while (h->root.root.type == bfd_link_hash_indirect
2343 || h->root.root.type == bfd_link_hash_warning)
2344 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2346 pbe = start = &h->got_entries;
2347 while ((be = *pbe) != NULL)
2349 if (be->use_count == 0)
2352 memset (be, 0xa5, sizeof (*be));
2355 if (be->gotobj != b)
2358 for (ae = *start; ae ; ae = ae->next)
2360 && ae->reloc_type == be->reloc_type
2361 && ae->addend == be->addend)
2363 ae->flags |= be->flags;
2364 ae->use_count += be->use_count;
2366 memset (be, 0xa5, sizeof (*be));
2370 total += alpha_got_entry_size (be->reloc_type);
2378 alpha_elf_tdata (bsub)->gotobj = a;
2380 alpha_elf_tdata (a)->total_got_size = total;
2382 /* Merge the two in_got chains. */
2387 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2390 alpha_elf_tdata (bsub)->in_got_link_next = b;
2394 /* Calculate the offsets for the got entries. */
2397 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2398 void * arg ATTRIBUTE_UNUSED)
2400 struct alpha_elf_got_entry *gotent;
2402 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2403 if (gotent->use_count > 0)
2405 struct alpha_elf_obj_tdata *td;
2406 bfd_size_type *plge;
2408 td = alpha_elf_tdata (gotent->gotobj);
2409 plge = &td->got->size;
2410 gotent->got_offset = *plge;
2411 *plge += alpha_got_entry_size (gotent->reloc_type);
2418 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2421 struct alpha_elf_link_hash_table * htab;
2423 htab = alpha_elf_hash_table (info);
2426 got_list = htab->got_list;
2428 /* First, zero out the .got sizes, as we may be recalculating the
2429 .got after optimizing it. */
2430 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2431 alpha_elf_tdata(i)->got->size = 0;
2433 /* Next, fill in the offsets for all the global entries. */
2434 alpha_elf_link_hash_traverse (htab,
2435 elf64_alpha_calc_got_offsets_for_symbol,
2438 /* Finally, fill in the offsets for the local entries. */
2439 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2441 bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2444 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2446 struct alpha_elf_got_entry **local_got_entries, *gotent;
2449 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2450 if (!local_got_entries)
2453 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2454 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2455 if (gotent->use_count > 0)
2457 gotent->got_offset = got_offset;
2458 got_offset += alpha_got_entry_size (gotent->reloc_type);
2462 alpha_elf_tdata(i)->got->size = got_offset;
2466 /* Constructs the gots. */
2469 elf64_alpha_size_got_sections (struct bfd_link_info *info,
2470 bfd_boolean may_merge)
2472 bfd *i, *got_list, *cur_got_obj = NULL;
2473 struct alpha_elf_link_hash_table * htab;
2475 htab = alpha_elf_hash_table (info);
2478 got_list = htab->got_list;
2480 /* On the first time through, pretend we have an existing got list
2481 consisting of all of the input files. */
2482 if (got_list == NULL)
2484 for (i = info->input_bfds; i ; i = i->link_next)
2488 if (! is_alpha_elf (i))
2491 this_got = alpha_elf_tdata (i)->gotobj;
2492 if (this_got == NULL)
2495 /* We are assuming no merging has yet occurred. */
2496 BFD_ASSERT (this_got == i);
2498 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2500 /* Yikes! A single object file has too many entries. */
2501 (*_bfd_error_handler)
2502 (_("%B: .got subsegment exceeds 64K (size %d)"),
2503 i, alpha_elf_tdata (this_got)->total_got_size);
2507 if (got_list == NULL)
2508 got_list = this_got;
2510 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2511 cur_got_obj = this_got;
2514 /* Strange degenerate case of no got references. */
2515 if (got_list == NULL)
2518 htab->got_list = got_list;
2521 cur_got_obj = got_list;
2522 if (cur_got_obj == NULL)
2527 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2530 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2532 elf64_alpha_merge_gots (cur_got_obj, i);
2534 alpha_elf_tdata(i)->got->size = 0;
2535 i = alpha_elf_tdata(i)->got_link_next;
2536 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2541 i = alpha_elf_tdata(i)->got_link_next;
2546 /* Once the gots have been merged, fill in the got offsets for
2547 everything therein. */
2548 elf64_alpha_calc_got_offsets (info);
2554 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2557 asection *splt = (asection *) data;
2558 struct alpha_elf_got_entry *gotent;
2559 bfd_boolean saw_one = FALSE;
2561 /* If we didn't need an entry before, we still don't. */
2562 if (!h->root.needs_plt)
2565 /* For each LITERAL got entry still in use, allocate a plt entry. */
2566 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2567 if (gotent->reloc_type == R_ALPHA_LITERAL
2568 && gotent->use_count > 0)
2570 if (splt->size == 0)
2571 splt->size = PLT_HEADER_SIZE;
2572 gotent->plt_offset = splt->size;
2573 splt->size += PLT_ENTRY_SIZE;
2577 /* If there weren't any, there's no longer a need for the PLT entry. */
2579 h->root.needs_plt = FALSE;
2584 /* Called from relax_section to rebuild the PLT in light of potential changes
2585 in the function's status. */
2588 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2590 asection *splt, *spltrel, *sgotplt;
2591 unsigned long entries;
2593 struct alpha_elf_link_hash_table * htab;
2595 htab = alpha_elf_hash_table (info);
2599 dynobj = elf_hash_table(info)->dynobj;
2600 splt = bfd_get_linker_section (dynobj, ".plt");
2606 alpha_elf_link_hash_traverse (htab,
2607 elf64_alpha_size_plt_section_1, splt);
2609 /* Every plt entry requires a JMP_SLOT relocation. */
2610 spltrel = bfd_get_linker_section (dynobj, ".rela.plt");
2614 if (elf64_alpha_use_secureplt)
2615 entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2617 entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2619 spltrel->size = entries * sizeof (Elf64_External_Rela);
2621 /* When using the secureplt, we need two words somewhere in the data
2622 segment for the dynamic linker to tell us where to go. This is the
2623 entire contents of the .got.plt section. */
2624 if (elf64_alpha_use_secureplt)
2626 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
2627 sgotplt->size = entries ? 16 : 0;
2632 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2633 struct bfd_link_info *info)
2636 struct alpha_elf_link_hash_table * htab;
2638 if (info->relocatable)
2641 htab = alpha_elf_hash_table (info);
2645 if (!elf64_alpha_size_got_sections (info, TRUE))
2648 /* Allocate space for all of the .got subsections. */
2650 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2652 asection *s = alpha_elf_tdata(i)->got;
2655 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2656 if (s->contents == NULL)
2664 /* The number of dynamic relocations required by a static relocation. */
2667 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2671 /* May appear in GOT entries. */
2673 return (dynamic ? 2 : shared ? 1 : 0);
2674 case R_ALPHA_TLSLDM:
2676 case R_ALPHA_LITERAL:
2677 return dynamic || shared;
2678 case R_ALPHA_GOTTPREL:
2679 return dynamic || (shared && !pie);
2680 case R_ALPHA_GOTDTPREL:
2683 /* May appear in data sections. */
2684 case R_ALPHA_REFLONG:
2685 case R_ALPHA_REFQUAD:
2686 return dynamic || shared;
2687 case R_ALPHA_TPREL64:
2688 return dynamic || (shared && !pie);
2690 /* Everything else is illegal. We'll issue an error during
2691 relocate_section. */
2697 /* Work out the sizes of the dynamic relocation entries. */
2700 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2701 struct bfd_link_info *info)
2703 bfd_boolean dynamic;
2704 struct alpha_elf_reloc_entry *relent;
2705 unsigned long entries;
2707 /* If the symbol was defined as a common symbol in a regular object
2708 file, and there was no definition in any dynamic object, then the
2709 linker will have allocated space for the symbol in a common
2710 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2711 set. This is done for dynamic symbols in
2712 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2713 symbols, somehow. */
2714 if (!h->root.def_regular
2715 && h->root.ref_regular
2716 && !h->root.def_dynamic
2717 && (h->root.root.type == bfd_link_hash_defined
2718 || h->root.root.type == bfd_link_hash_defweak)
2719 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2720 h->root.def_regular = 1;
2722 /* If the symbol is dynamic, we'll need all the relocations in their
2723 natural form. If this is a shared object, and it has been forced
2724 local, we'll need the same number of RELATIVE relocations. */
2725 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2727 /* If the symbol is a hidden undefined weak, then we never have any
2728 relocations. Avoid the loop which may want to add RELATIVE relocs
2729 based on info->shared. */
2730 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2733 for (relent = h->reloc_entries; relent; relent = relent->next)
2735 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2736 info->shared, info->pie);
2739 relent->srel->size +=
2740 entries * sizeof (Elf64_External_Rela) * relent->count;
2741 if (relent->reltext)
2742 info->flags |= DT_TEXTREL;
2749 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2753 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2754 struct bfd_link_info *info)
2756 bfd_boolean dynamic;
2757 struct alpha_elf_got_entry *gotent;
2758 unsigned long entries;
2760 /* If we're using a plt for this symbol, then all of its relocations
2761 for its got entries go into .rela.plt. */
2762 if (h->root.needs_plt)
2765 /* If the symbol is dynamic, we'll need all the relocations in their
2766 natural form. If this is a shared object, and it has been forced
2767 local, we'll need the same number of RELATIVE relocations. */
2768 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2770 /* If the symbol is a hidden undefined weak, then we never have any
2771 relocations. Avoid the loop which may want to add RELATIVE relocs
2772 based on info->shared. */
2773 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2777 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2778 if (gotent->use_count > 0)
2779 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2780 info->shared, info->pie);
2784 bfd *dynobj = elf_hash_table(info)->dynobj;
2785 asection *srel = bfd_get_linker_section (dynobj, ".rela.got");
2786 BFD_ASSERT (srel != NULL);
2787 srel->size += sizeof (Elf64_External_Rela) * entries;
2793 /* Set the sizes of the dynamic relocation sections. */
2796 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2798 unsigned long entries;
2801 struct alpha_elf_link_hash_table * htab;
2803 htab = alpha_elf_hash_table (info);
2807 /* Shared libraries often require RELATIVE relocs, and some relocs
2808 require attention for the main application as well. */
2811 for (i = htab->got_list;
2812 i ; i = alpha_elf_tdata(i)->got_link_next)
2816 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2818 struct alpha_elf_got_entry **local_got_entries, *gotent;
2821 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2822 if (!local_got_entries)
2825 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2826 for (gotent = local_got_entries[k];
2827 gotent ; gotent = gotent->next)
2828 if (gotent->use_count > 0)
2829 entries += (alpha_dynamic_entries_for_reloc
2830 (gotent->reloc_type, 0, info->shared, info->pie));
2834 dynobj = elf_hash_table(info)->dynobj;
2835 srel = bfd_get_linker_section (dynobj, ".rela.got");
2838 BFD_ASSERT (entries == 0);
2841 srel->size = sizeof (Elf64_External_Rela) * entries;
2843 /* Now do the non-local symbols. */
2844 alpha_elf_link_hash_traverse (htab,
2845 elf64_alpha_size_rela_got_1, info);
2848 /* Set the sizes of the dynamic sections. */
2851 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2852 struct bfd_link_info *info)
2857 struct alpha_elf_link_hash_table * htab;
2859 htab = alpha_elf_hash_table (info);
2863 dynobj = elf_hash_table(info)->dynobj;
2864 BFD_ASSERT(dynobj != NULL);
2866 if (elf_hash_table (info)->dynamic_sections_created)
2868 /* Set the contents of the .interp section to the interpreter. */
2869 if (info->executable)
2871 s = bfd_get_linker_section (dynobj, ".interp");
2872 BFD_ASSERT (s != NULL);
2873 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2874 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2877 /* Now that we've seen all of the input files, we can decide which
2878 symbols need dynamic relocation entries and which don't. We've
2879 collected information in check_relocs that we can now apply to
2880 size the dynamic relocation sections. */
2881 alpha_elf_link_hash_traverse (htab,
2882 elf64_alpha_calc_dynrel_sizes, info);
2884 elf64_alpha_size_rela_got_section (info);
2885 elf64_alpha_size_plt_section (info);
2887 /* else we're not dynamic and by definition we don't need such things. */
2889 /* The check_relocs and adjust_dynamic_symbol entry points have
2890 determined the sizes of the various dynamic sections. Allocate
2893 for (s = dynobj->sections; s != NULL; s = s->next)
2897 if (!(s->flags & SEC_LINKER_CREATED))
2900 /* It's OK to base decisions on the section name, because none
2901 of the dynobj section names depend upon the input files. */
2902 name = bfd_get_section_name (dynobj, s);
2904 if (CONST_STRNEQ (name, ".rela"))
2908 if (strcmp (name, ".rela.plt") == 0)
2911 /* We use the reloc_count field as a counter if we need
2912 to copy relocs into the output file. */
2916 else if (! CONST_STRNEQ (name, ".got")
2917 && strcmp (name, ".plt") != 0
2918 && strcmp (name, ".dynbss") != 0)
2920 /* It's not one of our dynamic sections, so don't allocate space. */
2926 /* If we don't need this section, strip it from the output file.
2927 This is to handle .rela.bss and .rela.plt. We must create it
2928 in create_dynamic_sections, because it must be created before
2929 the linker maps input sections to output sections. The
2930 linker does that before adjust_dynamic_symbol is called, and
2931 it is that function which decides whether anything needs to
2932 go into these sections. */
2933 if (!CONST_STRNEQ (name, ".got"))
2934 s->flags |= SEC_EXCLUDE;
2936 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2938 /* Allocate memory for the section contents. */
2939 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2940 if (s->contents == NULL)
2945 if (elf_hash_table (info)->dynamic_sections_created)
2947 /* Add some entries to the .dynamic section. We fill in the
2948 values later, in elf64_alpha_finish_dynamic_sections, but we
2949 must add the entries now so that we get the correct size for
2950 the .dynamic section. The DT_DEBUG entry is filled in by the
2951 dynamic linker and used by the debugger. */
2952 #define add_dynamic_entry(TAG, VAL) \
2953 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2955 if (info->executable)
2957 if (!add_dynamic_entry (DT_DEBUG, 0))
2963 if (!add_dynamic_entry (DT_PLTGOT, 0)
2964 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2965 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2966 || !add_dynamic_entry (DT_JMPREL, 0))
2969 if (elf64_alpha_use_secureplt
2970 && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2974 if (!add_dynamic_entry (DT_RELA, 0)
2975 || !add_dynamic_entry (DT_RELASZ, 0)
2976 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2979 if (info->flags & DF_TEXTREL)
2981 if (!add_dynamic_entry (DT_TEXTREL, 0))
2985 #undef add_dynamic_entry
2990 /* These functions do relaxation for Alpha ELF.
2992 Currently I'm only handling what I can do with existing compiler
2993 and assembler support, which means no instructions are removed,
2994 though some may be nopped. At this time GCC does not emit enough
2995 information to do all of the relaxing that is possible. It will
2996 take some not small amount of work for that to happen.
2998 There are a couple of interesting papers that I once read on this
2999 subject, that I cannot find references to at the moment, that
3000 related to Alpha in particular. They are by David Wall, then of
3003 struct alpha_relax_info
3008 Elf_Internal_Shdr *symtab_hdr;
3009 Elf_Internal_Rela *relocs, *relend;
3010 struct bfd_link_info *link_info;
3014 struct alpha_elf_link_hash_entry *h;
3015 struct alpha_elf_got_entry **first_gotent;
3016 struct alpha_elf_got_entry *gotent;
3017 bfd_boolean changed_contents;
3018 bfd_boolean changed_relocs;
3019 unsigned char other;
3022 static Elf_Internal_Rela *
3023 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
3024 Elf_Internal_Rela *relend,
3025 bfd_vma offset, int type)
3027 while (rel < relend)
3029 if (rel->r_offset == offset
3030 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
3038 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3039 Elf_Internal_Rela *irel, unsigned long r_type)
3042 bfd_signed_vma disp;
3044 /* Get the instruction. */
3045 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3047 if (insn >> 26 != OP_LDQ)
3049 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3050 ((*_bfd_error_handler)
3051 ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
3052 info->abfd, info->sec,
3053 (unsigned long) irel->r_offset, howto->name));
3057 /* Can't relax dynamic symbols. */
3058 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3061 /* Can't use local-exec relocations in shared libraries. */
3062 if (r_type == R_ALPHA_GOTTPREL
3063 && (info->link_info->shared && !info->link_info->pie))
3066 if (r_type == R_ALPHA_LITERAL)
3068 /* Look for nice constant addresses. This includes the not-uncommon
3069 special case of 0 for undefweak symbols. */
3070 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3071 || (!info->link_info->shared
3072 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3075 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3076 insn |= (symval & 0xffff);
3077 r_type = R_ALPHA_NONE;
3081 /* We may only create GPREL relocs during the second pass. */
3082 if (info->link_info->relax_pass == 0)
3085 disp = symval - info->gp;
3086 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3087 r_type = R_ALPHA_GPREL16;
3092 bfd_vma dtp_base, tp_base;
3094 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3095 dtp_base = alpha_get_dtprel_base (info->link_info);
3096 tp_base = alpha_get_tprel_base (info->link_info);
3097 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3099 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3103 case R_ALPHA_GOTDTPREL:
3104 r_type = R_ALPHA_DTPREL16;
3106 case R_ALPHA_GOTTPREL:
3107 r_type = R_ALPHA_TPREL16;
3115 if (disp < -0x8000 || disp >= 0x8000)
3118 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3119 info->changed_contents = TRUE;
3121 /* Reduce the use count on this got entry by one, possibly
3123 if (--info->gotent->use_count == 0)
3125 int sz = alpha_got_entry_size (r_type);
3126 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3128 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3131 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3132 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3133 info->changed_relocs = TRUE;
3135 /* ??? Search forward through this basic block looking for insns
3136 that use the target register. Stop after an insn modifying the
3137 register is seen, or after a branch or call.
3139 Any such memory load insn may be substituted by a load directly
3140 off the GP. This allows the memory load insn to be issued before
3141 the calculated GP register would otherwise be ready.
3143 Any such jsr insn can be replaced by a bsr if it is in range.
3145 This would mean that we'd have to _add_ relocations, the pain of
3146 which gives one pause. */
3152 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3154 /* If the function has the same gp, and we can identify that the
3155 function does not use its function pointer, we can eliminate the
3158 /* If the symbol is marked NOPV, we are being told the function never
3159 needs its procedure value. */
3160 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3163 /* If the symbol is marked STD_GP, we are being told the function does
3164 a normal ldgp in the first two words. */
3165 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3168 /* Otherwise, we may be able to identify a GP load in the first two
3169 words, which we can then skip. */
3172 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3175 /* Load the relocations from the section that the target symbol is in. */
3176 if (info->sec == info->tsec)
3178 tsec_relocs = info->relocs;
3179 tsec_relend = info->relend;
3184 tsec_relocs = (_bfd_elf_link_read_relocs
3185 (info->abfd, info->tsec, NULL,
3186 (Elf_Internal_Rela *) NULL,
3187 info->link_info->keep_memory));
3188 if (tsec_relocs == NULL)
3190 tsec_relend = tsec_relocs + info->tsec->reloc_count;
3191 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
3194 /* Recover the symbol's offset within the section. */
3195 ofs = (symval - info->tsec->output_section->vma
3196 - info->tsec->output_offset);
3198 /* Look for a GPDISP reloc. */
3199 gpdisp = (elf64_alpha_find_reloc_at_ofs
3200 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3202 if (!gpdisp || gpdisp->r_addend != 4)
3212 /* We've now determined that we can skip an initial gp load. Verify
3213 that the call and the target use the same gp. */
3214 if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3215 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3222 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3223 bfd_vma symval, Elf_Internal_Rela *irel)
3225 Elf_Internal_Rela *urel, *erel, *irelend = info->relend;
3227 bfd_signed_vma disp;
3230 bfd_boolean lit_reused = FALSE;
3231 bfd_boolean all_optimized = TRUE;
3232 bfd_boolean changed_contents;
3233 bfd_boolean changed_relocs;
3234 bfd_byte *contents = info->contents;
3235 bfd *abfd = info->abfd;
3236 bfd_vma sec_output_vma;
3237 unsigned int lit_insn;
3240 lit_insn = bfd_get_32 (abfd, contents + irel->r_offset);
3241 if (lit_insn >> 26 != OP_LDQ)
3243 ((*_bfd_error_handler)
3244 ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
3246 (unsigned long) irel->r_offset));
3250 /* Can't relax dynamic symbols. */
3251 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3254 changed_contents = info->changed_contents;
3255 changed_relocs = info->changed_relocs;
3256 sec_output_vma = info->sec->output_section->vma + info->sec->output_offset;
3257 relax_pass = info->link_info->relax_pass;
3259 /* Summarize how this particular LITERAL is used. */
3260 for (erel = irel+1, flags = 0; erel < irelend; ++erel)
3262 if (ELF64_R_TYPE (erel->r_info) != R_ALPHA_LITUSE)
3264 if (erel->r_addend <= 6)
3265 flags |= 1 << erel->r_addend;
3268 /* A little preparation for the loop... */
3269 disp = symval - info->gp;
3271 for (urel = irel+1; urel < erel; ++urel)
3273 bfd_vma urel_r_offset = urel->r_offset;
3276 bfd_signed_vma xdisp;
3277 Elf_Internal_Rela nrel;
3279 insn = bfd_get_32 (abfd, contents + urel_r_offset);
3281 switch (urel->r_addend)
3283 case LITUSE_ALPHA_ADDR:
3285 /* This type is really just a placeholder to note that all
3286 uses cannot be optimized, but to still allow some. */
3287 all_optimized = FALSE;
3290 case LITUSE_ALPHA_BASE:
3291 /* We may only create GPREL relocs during the second pass. */
3292 if (relax_pass == 0)
3294 all_optimized = FALSE;
3298 /* We can always optimize 16-bit displacements. */
3300 /* Extract the displacement from the instruction, sign-extending
3301 it if necessary, then test whether it is within 16 or 32 bits
3302 displacement from GP. */
3303 insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3305 xdisp = disp + insn_disp;
3306 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3307 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3308 && xdisp < 0x7fff8000);
3312 /* Take the op code and dest from this insn, take the base
3313 register from the literal insn. Leave the offset alone. */
3314 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3315 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3316 changed_contents = TRUE;
3319 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3321 nrel.r_addend = irel->r_addend;
3323 /* As we adjust, move the reloc to the end so that we don't
3324 break the LITERAL+LITUSE chain. */
3328 changed_relocs = TRUE;
3331 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3332 else if (fits32 && !(flags & ~6))
3334 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3336 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3338 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3339 bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset);
3341 changed_contents = TRUE;
3343 /* Since all relocs must be optimized, don't bother swapping
3344 this relocation to the end. */
3345 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3347 urel->r_addend = irel->r_addend;
3348 changed_relocs = TRUE;
3351 all_optimized = FALSE;
3354 case LITUSE_ALPHA_BYTOFF:
3355 /* We can always optimize byte instructions. */
3357 /* FIXME: sanity check the insn for byte op. Check that the
3358 literal dest reg is indeed Rb in the byte insn. */
3360 insn &= ~ (unsigned) 0x001ff000;
3361 insn |= ((symval & 7) << 13) | 0x1000;
3362 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3363 changed_contents = TRUE;
3366 nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3369 /* As we adjust, move the reloc to the end so that we don't
3370 break the LITERAL+LITUSE chain. */
3374 changed_relocs = TRUE;
3377 case LITUSE_ALPHA_JSR:
3378 case LITUSE_ALPHA_TLSGD:
3379 case LITUSE_ALPHA_TLSLDM:
3380 case LITUSE_ALPHA_JSRDIRECT:
3382 bfd_vma optdest, org;
3383 bfd_signed_vma odisp;
3385 /* For undefined weak symbols, we're mostly interested in getting
3386 rid of the got entry whenever possible, so optimize this to a
3387 use of the zero register. */
3388 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3391 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3393 changed_contents = TRUE;
3397 /* If not zero, place to jump without needing pv. */
3398 optdest = elf64_alpha_relax_opt_call (info, symval);
3399 org = sec_output_vma + urel_r_offset + 4;
3400 odisp = (optdest ? optdest : symval) - org;
3402 if (odisp >= -0x400000 && odisp < 0x400000)
3404 Elf_Internal_Rela *xrel;
3406 /* Preserve branch prediction call stack when possible. */
3407 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3408 insn = (OP_BSR << 26) | (insn & 0x03e00000);
3410 insn = (OP_BR << 26) | (insn & 0x03e00000);
3411 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3412 changed_contents = TRUE;
3415 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3417 nrel.r_addend = irel->r_addend;
3420 nrel.r_addend += optdest - symval;
3422 all_optimized = FALSE;
3424 /* Kill any HINT reloc that might exist for this insn. */
3425 xrel = (elf64_alpha_find_reloc_at_ofs
3426 (info->relocs, info->relend, urel_r_offset,
3429 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3431 /* As we adjust, move the reloc to the end so that we don't
3432 break the LITERAL+LITUSE chain. */
3437 info->changed_relocs = TRUE;
3440 all_optimized = FALSE;
3442 /* Even if the target is not in range for a direct branch,
3443 if we share a GP, we can eliminate the gp reload. */
3446 Elf_Internal_Rela *gpdisp
3447 = (elf64_alpha_find_reloc_at_ofs
3448 (info->relocs, irelend, urel_r_offset + 4,
3452 bfd_byte *p_ldah = contents + gpdisp->r_offset;
3453 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3454 unsigned int ldah = bfd_get_32 (abfd, p_ldah);
3455 unsigned int lda = bfd_get_32 (abfd, p_lda);
3457 /* Verify that the instruction is "ldah $29,0($26)".
3458 Consider a function that ends in a noreturn call,
3459 and that the next function begins with an ldgp,
3460 and that by accident there is no padding between.
3461 In that case the insn would use $27 as the base. */
3462 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3464 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_ldah);
3465 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda);
3467 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3468 changed_contents = TRUE;
3469 changed_relocs = TRUE;
3478 /* If we reused the literal instruction, we must have optimized all. */
3479 BFD_ASSERT(!lit_reused || all_optimized);
3481 /* If all cases were optimized, we can reduce the use count on this
3482 got entry by one, possibly eliminating it. */
3485 if (--info->gotent->use_count == 0)
3487 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3488 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3490 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3493 /* If the literal instruction is no longer needed (it may have been
3494 reused. We can eliminate it. */
3495 /* ??? For now, I don't want to deal with compacting the section,
3496 so just nop it out. */
3499 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3500 changed_relocs = TRUE;
3502 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset);
3503 changed_contents = TRUE;
3507 info->changed_contents = changed_contents;
3508 info->changed_relocs = changed_relocs;
3510 if (all_optimized || relax_pass == 0)
3512 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3516 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3517 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3520 unsigned int insn, tlsgd_reg;
3521 Elf_Internal_Rela *gpdisp, *hint;
3522 bfd_boolean dynamic, use_gottprel;
3523 unsigned long new_symndx;
3525 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3527 /* If a TLS symbol is accessed using IE at least once, there is no point
3528 to use dynamic model for it. */
3529 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3532 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3533 then we might as well relax to IE. */
3534 else if (info->link_info->shared && !dynamic
3535 && (info->link_info->flags & DF_STATIC_TLS))
3538 /* Otherwise we must be building an executable to do anything. */
3539 else if (info->link_info->shared)
3542 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3543 the matching LITUSE_TLS relocations. */
3544 if (irel + 2 >= info->relend)
3546 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3547 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3548 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3551 /* There must be a GPDISP relocation positioned immediately after the
3552 LITUSE relocation. */
3553 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3554 irel[2].r_offset + 4, R_ALPHA_GPDISP);
3558 pos[0] = info->contents + irel[0].r_offset;
3559 pos[1] = info->contents + irel[1].r_offset;
3560 pos[2] = info->contents + irel[2].r_offset;
3561 pos[3] = info->contents + gpdisp->r_offset;
3562 pos[4] = pos[3] + gpdisp->r_addend;
3564 /* Beware of the compiler hoisting part of the sequence out a loop
3565 and adjusting the destination register for the TLSGD insn. If this
3566 happens, there will be a move into $16 before the JSR insn, so only
3567 transformations of the first insn pair should use this register. */
3568 tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3569 tlsgd_reg = (tlsgd_reg >> 21) & 31;
3571 /* Generally, the positions are not allowed to be out of order, lest the
3572 modified insn sequence have different register lifetimes. We can make
3573 an exception when pos 1 is adjacent to pos 0. */
3574 if (pos[1] + 4 == pos[0])
3576 bfd_byte *tmp = pos[0];
3580 if (pos[1] >= pos[2] || pos[2] >= pos[3])
3583 /* Reduce the use count on the LITERAL relocation. Do this before we
3584 smash the symndx when we adjust the relocations below. */
3586 struct alpha_elf_got_entry *lit_gotent;
3587 struct alpha_elf_link_hash_entry *lit_h;
3590 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3591 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3592 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3594 while (lit_h->root.root.type == bfd_link_hash_indirect
3595 || lit_h->root.root.type == bfd_link_hash_warning)
3596 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3598 for (lit_gotent = lit_h->got_entries; lit_gotent ;
3599 lit_gotent = lit_gotent->next)
3600 if (lit_gotent->gotobj == info->gotobj
3601 && lit_gotent->reloc_type == R_ALPHA_LITERAL
3602 && lit_gotent->addend == irel[1].r_addend)
3604 BFD_ASSERT (lit_gotent);
3606 if (--lit_gotent->use_count == 0)
3608 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3609 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3615 lda $16,x($gp) !tlsgd!1
3616 ldq $27,__tls_get_addr($gp) !literal!1
3617 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3618 ldah $29,0($26) !gpdisp!2
3619 lda $29,0($29) !gpdisp!2
3621 ldq $16,x($gp) !gottprel
3626 or the first pair to
3627 lda $16,x($gp) !tprel
3630 ldah $16,x($gp) !tprelhi
3631 lda $16,x($16) !tprello
3635 use_gottprel = FALSE;
3636 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3638 /* Some compilers warn about a Boolean-looking expression being
3639 used in a switch. The explicit cast silences them. */
3640 switch ((int) (!dynamic && !info->link_info->shared))
3645 bfd_signed_vma disp;
3647 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3648 tp_base = alpha_get_tprel_base (info->link_info);
3649 disp = symval - tp_base;
3651 if (disp >= -0x8000 && disp < 0x8000)
3653 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3654 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3655 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3657 irel[0].r_offset = pos[0] - info->contents;
3658 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3659 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3662 else if (disp >= -(bfd_signed_vma) 0x80000000
3663 && disp < (bfd_signed_vma) 0x7fff8000
3664 && pos[0] + 4 == pos[1])
3666 insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3667 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3668 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3669 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3671 irel[0].r_offset = pos[0] - info->contents;
3672 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3673 irel[1].r_offset = pos[1] - info->contents;
3674 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3681 use_gottprel = TRUE;
3683 insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3684 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3685 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3687 irel[0].r_offset = pos[0] - info->contents;
3688 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3689 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3693 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3695 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3696 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3698 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3700 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3701 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3703 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3704 irel[2].r_offset, R_ALPHA_HINT);
3706 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3708 info->changed_contents = TRUE;
3709 info->changed_relocs = TRUE;
3711 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3712 if (--info->gotent->use_count == 0)
3714 int sz = alpha_got_entry_size (info->gotent->reloc_type);
3715 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3717 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3720 /* If we've switched to a GOTTPREL relocation, increment the reference
3721 count on that got entry. */
3724 struct alpha_elf_got_entry *tprel_gotent;
3726 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3727 tprel_gotent = tprel_gotent->next)
3728 if (tprel_gotent->gotobj == info->gotobj
3729 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3730 && tprel_gotent->addend == irel->r_addend)
3733 tprel_gotent->use_count++;
3736 if (info->gotent->use_count == 0)
3737 tprel_gotent = info->gotent;
3740 tprel_gotent = (struct alpha_elf_got_entry *)
3741 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3745 tprel_gotent->next = *info->first_gotent;
3746 *info->first_gotent = tprel_gotent;
3748 tprel_gotent->gotobj = info->gotobj;
3749 tprel_gotent->addend = irel->r_addend;
3750 tprel_gotent->got_offset = -1;
3751 tprel_gotent->reloc_done = 0;
3752 tprel_gotent->reloc_xlated = 0;
3755 tprel_gotent->use_count = 1;
3756 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3764 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3765 struct bfd_link_info *link_info, bfd_boolean *again)
3767 Elf_Internal_Shdr *symtab_hdr;
3768 Elf_Internal_Rela *internal_relocs;
3769 Elf_Internal_Rela *irel, *irelend;
3770 Elf_Internal_Sym *isymbuf = NULL;
3771 struct alpha_elf_got_entry **local_got_entries;
3772 struct alpha_relax_info info;
3773 struct alpha_elf_link_hash_table * htab;
3776 htab = alpha_elf_hash_table (link_info);
3780 /* There's nothing to change, yet. */
3783 if (link_info->relocatable
3784 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3785 != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3786 || sec->reloc_count == 0)
3789 BFD_ASSERT (is_alpha_elf (abfd));
3790 relax_pass = link_info->relax_pass;
3792 /* Make sure our GOT and PLT tables are up-to-date. */
3793 if (htab->relax_trip != link_info->relax_trip)
3795 htab->relax_trip = link_info->relax_trip;
3797 /* This should never fail after the initial round, since the only error
3798 is GOT overflow, and relaxation only shrinks the table. However, we
3799 may only merge got sections during the first pass. If we merge
3800 sections after we've created GPREL relocs, the GP for the merged
3801 section backs up which may put the relocs out of range. */
3802 if (!elf64_alpha_size_got_sections (link_info, relax_pass == 0))
3804 if (elf_hash_table (link_info)->dynamic_sections_created)
3806 elf64_alpha_size_plt_section (link_info);
3807 elf64_alpha_size_rela_got_section (link_info);
3811 symtab_hdr = &elf_symtab_hdr (abfd);
3812 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3814 /* Load the relocations for this section. */
3815 internal_relocs = (_bfd_elf_link_read_relocs
3816 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3817 link_info->keep_memory));
3818 if (internal_relocs == NULL)
3821 memset(&info, 0, sizeof (info));
3824 info.link_info = link_info;
3825 info.symtab_hdr = symtab_hdr;
3826 info.relocs = internal_relocs;
3827 info.relend = irelend = internal_relocs + sec->reloc_count;
3829 /* Find the GP for this object. Do not store the result back via
3830 _bfd_set_gp_value, since this could change again before final. */
3831 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3834 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3835 info.gp = (sgot->output_section->vma
3836 + sgot->output_offset
3840 /* Get the section contents. */
3841 if (elf_section_data (sec)->this_hdr.contents != NULL)
3842 info.contents = elf_section_data (sec)->this_hdr.contents;
3845 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3849 for (irel = internal_relocs; irel < irelend; irel++)
3852 struct alpha_elf_got_entry *gotent;
3853 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3854 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3856 /* Early exit for unhandled or unrelaxable relocations. */
3857 if (r_type != R_ALPHA_LITERAL)
3859 /* We complete everything except LITERAL in the first pass. */
3860 if (relax_pass != 0)
3862 if (r_type == R_ALPHA_TLSLDM)
3864 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3865 reloc to the STN_UNDEF (0) symbol so that they all match. */
3866 r_symndx = STN_UNDEF;
3868 else if (r_type != R_ALPHA_GOTDTPREL
3869 && r_type != R_ALPHA_GOTTPREL
3870 && r_type != R_ALPHA_TLSGD)
3874 /* Get the value of the symbol referred to by the reloc. */
3875 if (r_symndx < symtab_hdr->sh_info)
3877 /* A local symbol. */
3878 Elf_Internal_Sym *isym;
3880 /* Read this BFD's local symbols. */
3881 if (isymbuf == NULL)
3883 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3884 if (isymbuf == NULL)
3885 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3886 symtab_hdr->sh_info, 0,
3888 if (isymbuf == NULL)
3892 isym = isymbuf + r_symndx;
3894 /* Given the symbol for a TLSLDM reloc is ignored, this also
3895 means forcing the symbol value to the tp base. */
3896 if (r_type == R_ALPHA_TLSLDM)
3898 info.tsec = bfd_abs_section_ptr;
3899 symval = alpha_get_tprel_base (info.link_info);
3903 symval = isym->st_value;
3904 if (isym->st_shndx == SHN_UNDEF)
3906 else if (isym->st_shndx == SHN_ABS)
3907 info.tsec = bfd_abs_section_ptr;
3908 else if (isym->st_shndx == SHN_COMMON)
3909 info.tsec = bfd_com_section_ptr;
3911 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3915 info.other = isym->st_other;
3916 if (local_got_entries)
3917 info.first_gotent = &local_got_entries[r_symndx];
3920 info.first_gotent = &info.gotent;
3927 struct alpha_elf_link_hash_entry *h;
3929 indx = r_symndx - symtab_hdr->sh_info;
3930 h = alpha_elf_sym_hashes (abfd)[indx];
3931 BFD_ASSERT (h != NULL);
3933 while (h->root.root.type == bfd_link_hash_indirect
3934 || h->root.root.type == bfd_link_hash_warning)
3935 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3937 /* If the symbol is undefined, we can't do anything with it. */
3938 if (h->root.root.type == bfd_link_hash_undefined)
3941 /* If the symbol isn't defined in the current module,
3942 again we can't do anything. */
3943 if (h->root.root.type == bfd_link_hash_undefweak)
3945 info.tsec = bfd_abs_section_ptr;
3948 else if (!h->root.def_regular)
3950 /* Except for TLSGD relocs, which can sometimes be
3951 relaxed to GOTTPREL relocs. */
3952 if (r_type != R_ALPHA_TLSGD)
3954 info.tsec = bfd_abs_section_ptr;
3959 info.tsec = h->root.root.u.def.section;
3960 symval = h->root.root.u.def.value;
3964 info.other = h->root.other;
3965 info.first_gotent = &h->got_entries;
3968 /* Search for the got entry to be used by this relocation. */
3969 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3970 if (gotent->gotobj == info.gotobj
3971 && gotent->reloc_type == r_type
3972 && gotent->addend == irel->r_addend)
3974 info.gotent = gotent;
3976 symval += info.tsec->output_section->vma + info.tsec->output_offset;
3977 symval += irel->r_addend;
3981 case R_ALPHA_LITERAL:
3982 BFD_ASSERT(info.gotent != NULL);
3984 /* If there exist LITUSE relocations immediately following, this
3985 opens up all sorts of interesting optimizations, because we
3986 now know every location that this address load is used. */
3987 if (irel+1 < irelend
3988 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
3990 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
3995 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
4000 case R_ALPHA_GOTDTPREL:
4001 case R_ALPHA_GOTTPREL:
4002 BFD_ASSERT(info.gotent != NULL);
4003 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
4008 case R_ALPHA_TLSLDM:
4009 BFD_ASSERT(info.gotent != NULL);
4010 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
4011 r_type == R_ALPHA_TLSGD))
4018 && symtab_hdr->contents != (unsigned char *) isymbuf)
4020 if (!link_info->keep_memory)
4024 /* Cache the symbols for elf_link_input_bfd. */
4025 symtab_hdr->contents = (unsigned char *) isymbuf;
4029 if (info.contents != NULL
4030 && elf_section_data (sec)->this_hdr.contents != info.contents)
4032 if (!info.changed_contents && !link_info->keep_memory)
4033 free (info.contents);
4036 /* Cache the section contents for elf_link_input_bfd. */
4037 elf_section_data (sec)->this_hdr.contents = info.contents;
4041 if (elf_section_data (sec)->relocs != internal_relocs)
4043 if (!info.changed_relocs)
4044 free (internal_relocs);
4046 elf_section_data (sec)->relocs = internal_relocs;
4049 *again = info.changed_contents || info.changed_relocs;
4055 && symtab_hdr->contents != (unsigned char *) isymbuf)
4057 if (info.contents != NULL
4058 && elf_section_data (sec)->this_hdr.contents != info.contents)
4059 free (info.contents);
4060 if (internal_relocs != NULL
4061 && elf_section_data (sec)->relocs != internal_relocs)
4062 free (internal_relocs);
4066 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4067 into the next available slot in SREL. */
4070 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4071 asection *sec, asection *srel, bfd_vma offset,
4072 long dynindx, long rtype, bfd_vma addend)
4074 Elf_Internal_Rela outrel;
4077 BFD_ASSERT (srel != NULL);
4079 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4080 outrel.r_addend = addend;
4082 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4083 if ((offset | 1) != (bfd_vma) -1)
4084 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4086 memset (&outrel, 0, sizeof (outrel));
4088 loc = srel->contents;
4089 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4090 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4091 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4094 /* Relocate an Alpha ELF section for a relocatable link.
4096 We don't have to change anything unless the reloc is against a section
4097 symbol, in which case we have to adjust according to where the section
4098 symbol winds up in the output section. */
4101 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4102 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4103 bfd *input_bfd, asection *input_section,
4104 bfd_byte *contents ATTRIBUTE_UNUSED,
4105 Elf_Internal_Rela *relocs,
4106 Elf_Internal_Sym *local_syms,
4107 asection **local_sections)
4109 unsigned long symtab_hdr_sh_info;
4110 Elf_Internal_Rela *rel;
4111 Elf_Internal_Rela *relend;
4112 struct elf_link_hash_entry **sym_hashes;
4113 bfd_boolean ret_val = TRUE;
4115 symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4116 sym_hashes = elf_sym_hashes (input_bfd);
4118 relend = relocs + input_section->reloc_count;
4119 for (rel = relocs; rel < relend; rel++)
4121 unsigned long r_symndx;
4122 Elf_Internal_Sym *sym;
4124 unsigned long r_type;
4126 r_type = ELF64_R_TYPE (rel->r_info);
4127 if (r_type >= R_ALPHA_max)
4129 (*_bfd_error_handler)
4130 (_("%B: unknown relocation type %d"),
4131 input_bfd, (int) r_type);
4132 bfd_set_error (bfd_error_bad_value);
4137 /* The symbol associated with GPDISP and LITUSE is
4138 immaterial. Only the addend is significant. */
4139 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4142 r_symndx = ELF64_R_SYM (rel->r_info);
4143 if (r_symndx < symtab_hdr_sh_info)
4145 sym = local_syms + r_symndx;
4146 sec = local_sections[r_symndx];
4150 struct elf_link_hash_entry *h;
4152 h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4154 while (h->root.type == bfd_link_hash_indirect
4155 || h->root.type == bfd_link_hash_warning)
4156 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4158 if (h->root.type != bfd_link_hash_defined
4159 && h->root.type != bfd_link_hash_defweak)
4163 sec = h->root.u.def.section;
4166 if (sec != NULL && discarded_section (sec))
4167 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4169 elf64_alpha_howto_table + r_type, 0,
4172 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4173 rel->r_addend += sec->output_offset;
4179 /* Relocate an Alpha ELF section. */
4182 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4183 bfd *input_bfd, asection *input_section,
4184 bfd_byte *contents, Elf_Internal_Rela *relocs,
4185 Elf_Internal_Sym *local_syms,
4186 asection **local_sections)
4188 Elf_Internal_Shdr *symtab_hdr;
4189 Elf_Internal_Rela *rel;
4190 Elf_Internal_Rela *relend;
4191 asection *sgot, *srel, *srelgot;
4192 bfd *dynobj, *gotobj;
4193 bfd_vma gp, tp_base, dtp_base;
4194 struct alpha_elf_got_entry **local_got_entries;
4195 bfd_boolean ret_val;
4197 BFD_ASSERT (is_alpha_elf (input_bfd));
4199 /* Handle relocatable links with a smaller loop. */
4200 if (info->relocatable)
4201 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4202 input_section, contents, relocs,
4203 local_syms, local_sections);
4205 /* This is a final link. */
4209 symtab_hdr = &elf_symtab_hdr (input_bfd);
4211 dynobj = elf_hash_table (info)->dynobj;
4213 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
4217 if (input_section->flags & SEC_ALLOC)
4219 const char *section_name;
4220 section_name = (bfd_elf_string_from_elf_section
4221 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4222 _bfd_elf_single_rel_hdr (input_section)->sh_name));
4223 BFD_ASSERT(section_name != NULL);
4224 srel = bfd_get_linker_section (dynobj, section_name);
4229 /* Find the gp value for this input bfd. */
4230 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4233 sgot = alpha_elf_tdata (gotobj)->got;
4234 gp = _bfd_get_gp_value (gotobj);
4237 gp = (sgot->output_section->vma
4238 + sgot->output_offset
4240 _bfd_set_gp_value (gotobj, gp);
4249 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4251 if (elf_hash_table (info)->tls_sec != NULL)
4253 dtp_base = alpha_get_dtprel_base (info);
4254 tp_base = alpha_get_tprel_base (info);
4257 dtp_base = tp_base = 0;
4259 relend = relocs + input_section->reloc_count;
4260 for (rel = relocs; rel < relend; rel++)
4262 struct alpha_elf_link_hash_entry *h = NULL;
4263 struct alpha_elf_got_entry *gotent;
4264 bfd_reloc_status_type r;
4265 reloc_howto_type *howto;
4266 unsigned long r_symndx;
4267 Elf_Internal_Sym *sym = NULL;
4268 asection *sec = NULL;
4271 bfd_boolean dynamic_symbol_p;
4272 bfd_boolean unresolved_reloc = FALSE;
4273 bfd_boolean undef_weak_ref = FALSE;
4274 unsigned long r_type;
4276 r_type = ELF64_R_TYPE(rel->r_info);
4277 if (r_type >= R_ALPHA_max)
4279 (*_bfd_error_handler)
4280 (_("%B: unknown relocation type %d"),
4281 input_bfd, (int) r_type);
4282 bfd_set_error (bfd_error_bad_value);
4287 howto = elf64_alpha_howto_table + r_type;
4288 r_symndx = ELF64_R_SYM(rel->r_info);
4290 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4291 reloc to the STN_UNDEF (0) symbol so that they all match. */
4292 if (r_type == R_ALPHA_TLSLDM)
4293 r_symndx = STN_UNDEF;
4295 if (r_symndx < symtab_hdr->sh_info)
4298 sym = local_syms + r_symndx;
4299 sec = local_sections[r_symndx];
4301 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4303 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4304 this is hackery from relax_section. Force the value to
4305 be the tls module base. */
4306 if (r_symndx == STN_UNDEF
4307 && (r_type == R_ALPHA_TLSLDM
4308 || r_type == R_ALPHA_GOTTPREL
4309 || r_type == R_ALPHA_TPREL64
4310 || r_type == R_ALPHA_TPRELHI
4311 || r_type == R_ALPHA_TPRELLO
4312 || r_type == R_ALPHA_TPREL16))
4315 if (local_got_entries)
4316 gotent = local_got_entries[r_symndx];
4320 /* Need to adjust local GOT entries' addends for SEC_MERGE
4321 unless it has been done already. */
4322 if ((sec->flags & SEC_MERGE)
4323 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4324 && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4326 && !gotent->reloc_xlated)
4328 struct alpha_elf_got_entry *ent;
4330 for (ent = gotent; ent; ent = ent->next)
4332 ent->reloc_xlated = 1;
4333 if (ent->use_count == 0)
4337 _bfd_merged_section_offset (output_bfd, &msec,
4338 elf_section_data (sec)->
4340 sym->st_value + ent->addend);
4341 ent->addend -= sym->st_value;
4342 ent->addend += msec->output_section->vma
4343 + msec->output_offset
4344 - sec->output_section->vma
4345 - sec->output_offset;
4349 dynamic_symbol_p = FALSE;
4353 bfd_boolean warned, ignored;
4354 struct elf_link_hash_entry *hh;
4355 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4357 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4358 r_symndx, symtab_hdr, sym_hashes,
4360 unresolved_reloc, warned, ignored);
4366 && ! unresolved_reloc
4367 && hh->root.type == bfd_link_hash_undefweak)
4368 undef_weak_ref = TRUE;
4370 h = (struct alpha_elf_link_hash_entry *) hh;
4371 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4372 gotent = h->got_entries;
4375 if (sec != NULL && discarded_section (sec))
4376 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4377 rel, 1, relend, howto, 0, contents);
4379 addend = rel->r_addend;
4382 /* Search for the proper got entry. */
4383 for (; gotent ; gotent = gotent->next)
4384 if (gotent->gotobj == gotobj
4385 && gotent->reloc_type == r_type
4386 && gotent->addend == addend)
4391 case R_ALPHA_GPDISP:
4393 bfd_byte *p_ldah, *p_lda;
4395 BFD_ASSERT(gp != 0);
4397 value = (input_section->output_section->vma
4398 + input_section->output_offset
4401 p_ldah = contents + rel->r_offset;
4402 p_lda = p_ldah + rel->r_addend;
4404 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4409 case R_ALPHA_LITERAL:
4410 BFD_ASSERT(sgot != NULL);
4411 BFD_ASSERT(gp != 0);
4412 BFD_ASSERT(gotent != NULL);
4413 BFD_ASSERT(gotent->use_count >= 1);
4415 if (!gotent->reloc_done)
4417 gotent->reloc_done = 1;
4419 bfd_put_64 (output_bfd, value,
4420 sgot->contents + gotent->got_offset);
4422 /* If the symbol has been forced local, output a
4423 RELATIVE reloc, otherwise it will be handled in
4424 finish_dynamic_symbol. */
4425 if (info->shared && !dynamic_symbol_p && !undef_weak_ref)
4426 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4427 gotent->got_offset, 0,
4428 R_ALPHA_RELATIVE, value);
4431 value = (sgot->output_section->vma
4432 + sgot->output_offset
4433 + gotent->got_offset);
4437 case R_ALPHA_GPREL32:
4438 case R_ALPHA_GPREL16:
4439 case R_ALPHA_GPRELLOW:
4440 if (dynamic_symbol_p)
4442 (*_bfd_error_handler)
4443 (_("%B: gp-relative relocation against dynamic symbol %s"),
4444 input_bfd, h->root.root.root.string);
4447 BFD_ASSERT(gp != 0);
4451 case R_ALPHA_GPRELHIGH:
4452 if (dynamic_symbol_p)
4454 (*_bfd_error_handler)
4455 (_("%B: gp-relative relocation against dynamic symbol %s"),
4456 input_bfd, h->root.root.root.string);
4459 BFD_ASSERT(gp != 0);
4461 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4465 /* A call to a dynamic symbol is definitely out of range of
4466 the 16-bit displacement. Don't bother writing anything. */
4467 if (dynamic_symbol_p)
4472 /* The regular PC-relative stuff measures from the start of
4473 the instruction rather than the end. */
4477 case R_ALPHA_BRADDR:
4478 if (dynamic_symbol_p)
4480 (*_bfd_error_handler)
4481 (_("%B: pc-relative relocation against dynamic symbol %s"),
4482 input_bfd, h->root.root.root.string);
4485 /* The regular PC-relative stuff measures from the start of
4486 the instruction rather than the end. */
4495 /* The regular PC-relative stuff measures from the start of
4496 the instruction rather than the end. */
4499 /* The source and destination gp must be the same. Note that
4500 the source will always have an assigned gp, since we forced
4501 one in check_relocs, but that the destination may not, as
4502 it might not have had any relocations at all. Also take
4503 care not to crash if H is an undefined symbol. */
4504 if (h != NULL && sec != NULL
4505 && alpha_elf_tdata (sec->owner)->gotobj
4506 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4508 (*_bfd_error_handler)
4509 (_("%B: change in gp: BRSGP %s"),
4510 input_bfd, h->root.root.root.string);
4514 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4516 other = h->root.other;
4518 other = sym->st_other;
4519 switch (other & STO_ALPHA_STD_GPLOAD)
4521 case STO_ALPHA_NOPV:
4523 case STO_ALPHA_STD_GPLOAD:
4528 name = h->root.root.root.string;
4531 name = (bfd_elf_string_from_elf_section
4532 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4534 name = _("<unknown>");
4535 else if (name[0] == 0)
4536 name = bfd_section_name (input_bfd, sec);
4538 (*_bfd_error_handler)
4539 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4548 case R_ALPHA_REFLONG:
4549 case R_ALPHA_REFQUAD:
4550 case R_ALPHA_DTPREL64:
4551 case R_ALPHA_TPREL64:
4553 long dynindx, dyntype = r_type;
4556 /* Careful here to remember RELATIVE relocations for global
4557 variables for symbolic shared objects. */
4559 if (dynamic_symbol_p)
4561 BFD_ASSERT(h->root.dynindx != -1);
4562 dynindx = h->root.dynindx;
4564 addend = 0, value = 0;
4566 else if (r_type == R_ALPHA_DTPREL64)
4568 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4572 else if (r_type == R_ALPHA_TPREL64)
4574 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4575 if (!info->shared || info->pie)
4581 dynaddend = value - dtp_base;
4583 else if (info->shared
4584 && r_symndx != STN_UNDEF
4585 && (input_section->flags & SEC_ALLOC)
4587 && !(unresolved_reloc
4588 && (_bfd_elf_section_offset (output_bfd, info,
4593 if (r_type == R_ALPHA_REFLONG)
4595 (*_bfd_error_handler)
4596 (_("%B: unhandled dynamic relocation against %s"),
4598 h->root.root.root.string);
4602 dyntype = R_ALPHA_RELATIVE;
4608 if (input_section->flags & SEC_ALLOC)
4609 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4610 srel, rel->r_offset, dynindx,
4611 dyntype, dynaddend);
4615 case R_ALPHA_SREL16:
4616 case R_ALPHA_SREL32:
4617 case R_ALPHA_SREL64:
4618 if (dynamic_symbol_p)
4620 (*_bfd_error_handler)
4621 (_("%B: pc-relative relocation against dynamic symbol %s"),
4622 input_bfd, h->root.root.root.string);
4625 else if ((info->shared || info->pie) && undef_weak_ref)
4627 (*_bfd_error_handler)
4628 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4629 input_bfd, h->root.root.root.string);
4634 /* ??? .eh_frame references to discarded sections will be smashed
4635 to relocations against SHN_UNDEF. The .eh_frame format allows
4636 NULL to be encoded as 0 in any format, so this works here. */
4637 if (r_symndx == STN_UNDEF
4638 || (unresolved_reloc
4639 && _bfd_elf_section_offset (output_bfd, info,
4641 rel->r_offset) == (bfd_vma) -1))
4642 howto = (elf64_alpha_howto_table
4643 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4646 case R_ALPHA_TLSLDM:
4647 /* Ignore the symbol for the relocation. The result is always
4648 the current module. */
4649 dynamic_symbol_p = 0;
4653 if (!gotent->reloc_done)
4655 gotent->reloc_done = 1;
4657 /* Note that the module index for the main program is 1. */
4658 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4659 sgot->contents + gotent->got_offset);
4661 /* If the symbol has been forced local, output a
4662 DTPMOD64 reloc, otherwise it will be handled in
4663 finish_dynamic_symbol. */
4664 if (info->shared && !dynamic_symbol_p)
4665 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4666 gotent->got_offset, 0,
4667 R_ALPHA_DTPMOD64, 0);
4669 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4673 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4676 bfd_put_64 (output_bfd, value,
4677 sgot->contents + gotent->got_offset + 8);
4680 value = (sgot->output_section->vma
4681 + sgot->output_offset
4682 + gotent->got_offset);
4686 case R_ALPHA_DTPRELHI:
4687 case R_ALPHA_DTPRELLO:
4688 case R_ALPHA_DTPREL16:
4689 if (dynamic_symbol_p)
4691 (*_bfd_error_handler)
4692 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4693 input_bfd, h->root.root.root.string);
4696 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4698 if (r_type == R_ALPHA_DTPRELHI)
4699 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4702 case R_ALPHA_TPRELHI:
4703 case R_ALPHA_TPRELLO:
4704 case R_ALPHA_TPREL16:
4705 if (info->shared && !info->pie)
4707 (*_bfd_error_handler)
4708 (_("%B: TLS local exec code cannot be linked into shared objects"),
4712 else if (dynamic_symbol_p)
4714 (*_bfd_error_handler)
4715 (_("%B: tp-relative relocation against dynamic symbol %s"),
4716 input_bfd, h->root.root.root.string);
4719 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4721 if (r_type == R_ALPHA_TPRELHI)
4722 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4725 case R_ALPHA_GOTDTPREL:
4726 case R_ALPHA_GOTTPREL:
4727 BFD_ASSERT(sgot != NULL);
4728 BFD_ASSERT(gp != 0);
4729 BFD_ASSERT(gotent != NULL);
4730 BFD_ASSERT(gotent->use_count >= 1);
4732 if (!gotent->reloc_done)
4734 gotent->reloc_done = 1;
4736 if (dynamic_symbol_p)
4740 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4741 if (r_type == R_ALPHA_GOTDTPREL)
4743 else if (!info->shared)
4747 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4748 gotent->got_offset, 0,
4754 bfd_put_64 (output_bfd, value,
4755 sgot->contents + gotent->got_offset);
4758 value = (sgot->output_section->vma
4759 + sgot->output_offset
4760 + gotent->got_offset);
4766 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4767 contents, rel->r_offset, value, 0);
4776 case bfd_reloc_overflow:
4780 /* Don't warn if the overflow is due to pc relative reloc
4781 against discarded section. Section optimization code should
4784 if (r_symndx < symtab_hdr->sh_info
4785 && sec != NULL && howto->pc_relative
4786 && discarded_section (sec))
4793 name = (bfd_elf_string_from_elf_section
4794 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4798 name = bfd_section_name (input_bfd, sec);
4800 if (! ((*info->callbacks->reloc_overflow)
4801 (info, (h ? &h->root.root : NULL), name, howto->name,
4802 (bfd_vma) 0, input_bfd, input_section,
4809 case bfd_reloc_outofrange:
4817 /* Finish up dynamic symbol handling. We set the contents of various
4818 dynamic sections here. */
4821 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4822 struct elf_link_hash_entry *h,
4823 Elf_Internal_Sym *sym)
4825 struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4826 bfd *dynobj = elf_hash_table(info)->dynobj;
4830 /* Fill in the .plt entry for this symbol. */
4831 asection *splt, *sgot, *srel;
4832 Elf_Internal_Rela outrel;
4834 bfd_vma got_addr, plt_addr;
4836 struct alpha_elf_got_entry *gotent;
4838 BFD_ASSERT (h->dynindx != -1);
4840 splt = bfd_get_linker_section (dynobj, ".plt");
4841 BFD_ASSERT (splt != NULL);
4842 srel = bfd_get_linker_section (dynobj, ".rela.plt");
4843 BFD_ASSERT (srel != NULL);
4845 for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4846 if (gotent->reloc_type == R_ALPHA_LITERAL
4847 && gotent->use_count > 0)
4852 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4853 BFD_ASSERT (sgot != NULL);
4855 BFD_ASSERT (gotent->got_offset != -1);
4856 BFD_ASSERT (gotent->plt_offset != -1);
4858 got_addr = (sgot->output_section->vma
4859 + sgot->output_offset
4860 + gotent->got_offset);
4861 plt_addr = (splt->output_section->vma
4862 + splt->output_offset
4863 + gotent->plt_offset);
4865 plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4867 /* Fill in the entry in the procedure linkage table. */
4868 if (elf64_alpha_use_secureplt)
4870 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4871 insn = INSN_AD (INSN_BR, 31, disp);
4872 bfd_put_32 (output_bfd, insn,
4873 splt->contents + gotent->plt_offset);
4875 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4876 / NEW_PLT_ENTRY_SIZE);
4880 disp = -(gotent->plt_offset + 4);
4881 insn = INSN_AD (INSN_BR, 28, disp);
4882 bfd_put_32 (output_bfd, insn,
4883 splt->contents + gotent->plt_offset);
4884 bfd_put_32 (output_bfd, INSN_UNOP,
4885 splt->contents + gotent->plt_offset + 4);
4886 bfd_put_32 (output_bfd, INSN_UNOP,
4887 splt->contents + gotent->plt_offset + 8);
4889 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4890 / OLD_PLT_ENTRY_SIZE);
4893 /* Fill in the entry in the .rela.plt section. */
4894 outrel.r_offset = got_addr;
4895 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4896 outrel.r_addend = 0;
4898 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4899 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4901 /* Fill in the entry in the .got. */
4902 bfd_put_64 (output_bfd, plt_addr,
4903 sgot->contents + gotent->got_offset);
4906 else if (alpha_elf_dynamic_symbol_p (h, info))
4908 /* Fill in the dynamic relocations for this symbol's .got entries. */
4910 struct alpha_elf_got_entry *gotent;
4912 srel = bfd_get_linker_section (dynobj, ".rela.got");
4913 BFD_ASSERT (srel != NULL);
4915 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4917 gotent = gotent->next)
4922 if (gotent->use_count == 0)
4925 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4927 r_type = gotent->reloc_type;
4930 case R_ALPHA_LITERAL:
4931 r_type = R_ALPHA_GLOB_DAT;
4934 r_type = R_ALPHA_DTPMOD64;
4936 case R_ALPHA_GOTDTPREL:
4937 r_type = R_ALPHA_DTPREL64;
4939 case R_ALPHA_GOTTPREL:
4940 r_type = R_ALPHA_TPREL64;
4942 case R_ALPHA_TLSLDM:
4947 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4948 gotent->got_offset, h->dynindx,
4949 r_type, gotent->addend);
4951 if (gotent->reloc_type == R_ALPHA_TLSGD)
4952 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4953 gotent->got_offset + 8, h->dynindx,
4954 R_ALPHA_DTPREL64, gotent->addend);
4958 /* Mark some specially defined symbols as absolute. */
4959 if (h == elf_hash_table (info)->hdynamic
4960 || h == elf_hash_table (info)->hgot
4961 || h == elf_hash_table (info)->hplt)
4962 sym->st_shndx = SHN_ABS;
4967 /* Finish up the dynamic sections. */
4970 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
4971 struct bfd_link_info *info)
4976 dynobj = elf_hash_table (info)->dynobj;
4977 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4979 if (elf_hash_table (info)->dynamic_sections_created)
4981 asection *splt, *sgotplt, *srelaplt;
4982 Elf64_External_Dyn *dyncon, *dynconend;
4983 bfd_vma plt_vma, gotplt_vma;
4985 splt = bfd_get_linker_section (dynobj, ".plt");
4986 srelaplt = bfd_get_linker_section (output_bfd, ".rela.plt");
4987 BFD_ASSERT (splt != NULL && sdyn != NULL);
4989 plt_vma = splt->output_section->vma + splt->output_offset;
4992 if (elf64_alpha_use_secureplt)
4994 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
4995 BFD_ASSERT (sgotplt != NULL);
4996 if (sgotplt->size > 0)
4997 gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
5000 dyncon = (Elf64_External_Dyn *) sdyn->contents;
5001 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5002 for (; dyncon < dynconend; dyncon++)
5004 Elf_Internal_Dyn dyn;
5006 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5012 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
5015 dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
5018 dyn.d_un.d_ptr = srelaplt ? srelaplt->vma : 0;
5022 /* My interpretation of the TIS v1.1 ELF document indicates
5023 that RELASZ should not include JMPREL. This is not what
5024 the rest of the BFD does. It is, however, what the
5025 glibc ld.so wants. Do this fixup here until we found
5026 out who is right. */
5028 dyn.d_un.d_val -= srelaplt->size;
5032 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5035 /* Initialize the plt header. */
5041 if (elf64_alpha_use_secureplt)
5043 ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
5045 insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
5046 bfd_put_32 (output_bfd, insn, splt->contents);
5048 insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
5049 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5051 insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
5052 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5054 insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5055 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5057 insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5058 bfd_put_32 (output_bfd, insn, splt->contents + 16);
5060 insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5061 bfd_put_32 (output_bfd, insn, splt->contents + 20);
5063 insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5064 bfd_put_32 (output_bfd, insn, splt->contents + 24);
5066 insn = INSN_AB (INSN_JMP, 31, 27);
5067 bfd_put_32 (output_bfd, insn, splt->contents + 28);
5069 insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5070 bfd_put_32 (output_bfd, insn, splt->contents + 32);
5074 insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */
5075 bfd_put_32 (output_bfd, insn, splt->contents);
5077 insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5078 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5081 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5083 insn = INSN_AB (INSN_JMP, 27, 27);
5084 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5086 /* The next two words will be filled in by ld.so. */
5087 bfd_put_64 (output_bfd, 0, splt->contents + 16);
5088 bfd_put_64 (output_bfd, 0, splt->contents + 24);
5091 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5098 /* We need to use a special link routine to handle the .mdebug section.
5099 We need to merge all instances of these sections together, not write
5100 them all out sequentially. */
5103 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5106 struct bfd_link_order *p;
5107 asection *mdebug_sec;
5108 struct ecoff_debug_info debug;
5109 const struct ecoff_debug_swap *swap
5110 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5111 HDRR *symhdr = &debug.symbolic_header;
5112 void * mdebug_handle = NULL;
5113 struct alpha_elf_link_hash_table * htab;
5115 htab = alpha_elf_hash_table (info);
5119 /* Go through the sections and collect the mdebug information. */
5121 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5123 if (strcmp (o->name, ".mdebug") == 0)
5125 struct extsym_info einfo;
5127 /* We have found the .mdebug section in the output file.
5128 Look through all the link_orders comprising it and merge
5129 the information together. */
5130 symhdr->magic = swap->sym_magic;
5131 /* FIXME: What should the version stamp be? */
5133 symhdr->ilineMax = 0;
5137 symhdr->isymMax = 0;
5138 symhdr->ioptMax = 0;
5139 symhdr->iauxMax = 0;
5141 symhdr->issExtMax = 0;
5144 symhdr->iextMax = 0;
5146 /* We accumulate the debugging information itself in the
5147 debug_info structure. */
5149 debug.external_dnr = NULL;
5150 debug.external_pdr = NULL;
5151 debug.external_sym = NULL;
5152 debug.external_opt = NULL;
5153 debug.external_aux = NULL;
5155 debug.ssext = debug.ssext_end = NULL;
5156 debug.external_fdr = NULL;
5157 debug.external_rfd = NULL;
5158 debug.external_ext = debug.external_ext_end = NULL;
5160 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5161 if (mdebug_handle == NULL)
5170 static const char * const name[] =
5172 ".text", ".init", ".fini", ".data",
5173 ".rodata", ".sdata", ".sbss", ".bss"
5175 static const int sc[] = { scText, scInit, scFini, scData,
5176 scRData, scSData, scSBss, scBss };
5179 esym.cobol_main = 0;
5183 esym.asym.iss = issNil;
5184 esym.asym.st = stLocal;
5185 esym.asym.reserved = 0;
5186 esym.asym.index = indexNil;
5187 for (i = 0; i < 8; i++)
5189 esym.asym.sc = sc[i];
5190 s = bfd_get_section_by_name (abfd, name[i]);
5193 esym.asym.value = s->vma;
5194 last = s->vma + s->size;
5197 esym.asym.value = last;
5199 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5205 for (p = o->map_head.link_order;
5206 p != (struct bfd_link_order *) NULL;
5209 asection *input_section;
5211 const struct ecoff_debug_swap *input_swap;
5212 struct ecoff_debug_info input_debug;
5216 if (p->type != bfd_indirect_link_order)
5218 if (p->type == bfd_data_link_order)
5223 input_section = p->u.indirect.section;
5224 input_bfd = input_section->owner;
5226 if (! is_alpha_elf (input_bfd))
5227 /* I don't know what a non ALPHA ELF bfd would be
5228 doing with a .mdebug section, but I don't really
5229 want to deal with it. */
5232 input_swap = (get_elf_backend_data (input_bfd)
5233 ->elf_backend_ecoff_debug_swap);
5235 BFD_ASSERT (p->size == input_section->size);
5237 /* The ECOFF linking code expects that we have already
5238 read in the debugging information and set up an
5239 ecoff_debug_info structure, so we do that now. */
5240 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5244 if (! (bfd_ecoff_debug_accumulate
5245 (mdebug_handle, abfd, &debug, swap, input_bfd,
5246 &input_debug, input_swap, info)))
5249 /* Loop through the external symbols. For each one with
5250 interesting information, try to find the symbol in
5251 the linker global hash table and save the information
5252 for the output external symbols. */
5253 eraw_src = (char *) input_debug.external_ext;
5254 eraw_end = (eraw_src
5255 + (input_debug.symbolic_header.iextMax
5256 * input_swap->external_ext_size));
5258 eraw_src < eraw_end;
5259 eraw_src += input_swap->external_ext_size)
5263 struct alpha_elf_link_hash_entry *h;
5265 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5266 if (ext.asym.sc == scNil
5267 || ext.asym.sc == scUndefined
5268 || ext.asym.sc == scSUndefined)
5271 name = input_debug.ssext + ext.asym.iss;
5272 h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5273 if (h == NULL || h->esym.ifd != -2)
5279 < input_debug.symbolic_header.ifdMax);
5280 ext.ifd = input_debug.ifdmap[ext.ifd];
5286 /* Free up the information we just read. */
5287 free (input_debug.line);
5288 free (input_debug.external_dnr);
5289 free (input_debug.external_pdr);
5290 free (input_debug.external_sym);
5291 free (input_debug.external_opt);
5292 free (input_debug.external_aux);
5293 free (input_debug.ss);
5294 free (input_debug.ssext);
5295 free (input_debug.external_fdr);
5296 free (input_debug.external_rfd);
5297 free (input_debug.external_ext);
5299 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5300 elf_link_input_bfd ignores this section. */
5301 input_section->flags &=~ SEC_HAS_CONTENTS;
5304 /* Build the external symbol information. */
5307 einfo.debug = &debug;
5309 einfo.failed = FALSE;
5310 elf_link_hash_traverse (elf_hash_table (info),
5311 elf64_alpha_output_extsym,
5316 /* Set the size of the .mdebug section. */
5317 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5319 /* Skip this section later on (I don't think this currently
5320 matters, but someday it might). */
5321 o->map_head.link_order = (struct bfd_link_order *) NULL;
5327 /* Invoke the regular ELF backend linker to do all the work. */
5328 if (! bfd_elf_final_link (abfd, info))
5331 /* Now write out the computed sections. */
5333 /* The .got subsections... */
5335 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5336 for (i = htab->got_list;
5338 i = alpha_elf_tdata(i)->got_link_next)
5342 /* elf_bfd_final_link already did everything in dynobj. */
5346 sgot = alpha_elf_tdata(i)->got;
5347 if (! bfd_set_section_contents (abfd, sgot->output_section,
5349 (file_ptr) sgot->output_offset,
5355 if (mdebug_sec != (asection *) NULL)
5357 BFD_ASSERT (abfd->output_has_begun);
5358 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5360 mdebug_sec->filepos))
5363 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5369 static enum elf_reloc_type_class
5370 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5371 const asection *rel_sec ATTRIBUTE_UNUSED,
5372 const Elf_Internal_Rela *rela)
5374 switch ((int) ELF64_R_TYPE (rela->r_info))
5376 case R_ALPHA_RELATIVE:
5377 return reloc_class_relative;
5378 case R_ALPHA_JMP_SLOT:
5379 return reloc_class_plt;
5381 return reloc_class_copy;
5383 return reloc_class_normal;
5387 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5389 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5390 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5391 { NULL, 0, 0, 0, 0 }
5394 /* ECOFF swapping routines. These are used when dealing with the
5395 .mdebug section, which is in the ECOFF debugging format. Copied
5396 from elf32-mips.c. */
5397 static const struct ecoff_debug_swap
5398 elf64_alpha_ecoff_debug_swap =
5400 /* Symbol table magic number. */
5402 /* Alignment of debugging information. E.g., 4. */
5404 /* Sizes of external symbolic information. */
5405 sizeof (struct hdr_ext),
5406 sizeof (struct dnr_ext),
5407 sizeof (struct pdr_ext),
5408 sizeof (struct sym_ext),
5409 sizeof (struct opt_ext),
5410 sizeof (struct fdr_ext),
5411 sizeof (struct rfd_ext),
5412 sizeof (struct ext_ext),
5413 /* Functions to swap in external symbolic data. */
5422 _bfd_ecoff_swap_tir_in,
5423 _bfd_ecoff_swap_rndx_in,
5424 /* Functions to swap out external symbolic data. */
5433 _bfd_ecoff_swap_tir_out,
5434 _bfd_ecoff_swap_rndx_out,
5435 /* Function to read in symbolic data. */
5436 elf64_alpha_read_ecoff_info
5439 /* Use a non-standard hash bucket size of 8. */
5441 static const struct elf_size_info alpha_elf_size_info =
5443 sizeof (Elf64_External_Ehdr),
5444 sizeof (Elf64_External_Phdr),
5445 sizeof (Elf64_External_Shdr),
5446 sizeof (Elf64_External_Rel),
5447 sizeof (Elf64_External_Rela),
5448 sizeof (Elf64_External_Sym),
5449 sizeof (Elf64_External_Dyn),
5450 sizeof (Elf_External_Note),
5454 ELFCLASS64, EV_CURRENT,
5455 bfd_elf64_write_out_phdrs,
5456 bfd_elf64_write_shdrs_and_ehdr,
5457 bfd_elf64_checksum_contents,
5458 bfd_elf64_write_relocs,
5459 bfd_elf64_swap_symbol_in,
5460 bfd_elf64_swap_symbol_out,
5461 bfd_elf64_slurp_reloc_table,
5462 bfd_elf64_slurp_symbol_table,
5463 bfd_elf64_swap_dyn_in,
5464 bfd_elf64_swap_dyn_out,
5465 bfd_elf64_swap_reloc_in,
5466 bfd_elf64_swap_reloc_out,
5467 bfd_elf64_swap_reloca_in,
5468 bfd_elf64_swap_reloca_out
5471 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5472 #define TARGET_LITTLE_NAME "elf64-alpha"
5473 #define ELF_ARCH bfd_arch_alpha
5474 #define ELF_TARGET_ID ALPHA_ELF_DATA
5475 #define ELF_MACHINE_CODE EM_ALPHA
5476 #define ELF_MAXPAGESIZE 0x10000
5477 #define ELF_COMMONPAGESIZE 0x2000
5479 #define bfd_elf64_bfd_link_hash_table_create \
5480 elf64_alpha_bfd_link_hash_table_create
5482 #define bfd_elf64_bfd_reloc_type_lookup \
5483 elf64_alpha_bfd_reloc_type_lookup
5484 #define bfd_elf64_bfd_reloc_name_lookup \
5485 elf64_alpha_bfd_reloc_name_lookup
5486 #define elf_info_to_howto \
5487 elf64_alpha_info_to_howto
5489 #define bfd_elf64_mkobject \
5490 elf64_alpha_mkobject
5491 #define elf_backend_object_p \
5492 elf64_alpha_object_p
5494 #define elf_backend_section_from_shdr \
5495 elf64_alpha_section_from_shdr
5496 #define elf_backend_section_flags \
5497 elf64_alpha_section_flags
5498 #define elf_backend_fake_sections \
5499 elf64_alpha_fake_sections
5501 #define bfd_elf64_bfd_is_local_label_name \
5502 elf64_alpha_is_local_label_name
5503 #define bfd_elf64_find_nearest_line \
5504 elf64_alpha_find_nearest_line
5505 #define bfd_elf64_bfd_relax_section \
5506 elf64_alpha_relax_section
5508 #define elf_backend_add_symbol_hook \
5509 elf64_alpha_add_symbol_hook
5510 #define elf_backend_relocs_compatible \
5511 _bfd_elf_relocs_compatible
5512 #define elf_backend_check_relocs \
5513 elf64_alpha_check_relocs
5514 #define elf_backend_create_dynamic_sections \
5515 elf64_alpha_create_dynamic_sections
5516 #define elf_backend_adjust_dynamic_symbol \
5517 elf64_alpha_adjust_dynamic_symbol
5518 #define elf_backend_merge_symbol_attribute \
5519 elf64_alpha_merge_symbol_attribute
5520 #define elf_backend_copy_indirect_symbol \
5521 elf64_alpha_copy_indirect_symbol
5522 #define elf_backend_always_size_sections \
5523 elf64_alpha_always_size_sections
5524 #define elf_backend_size_dynamic_sections \
5525 elf64_alpha_size_dynamic_sections
5526 #define elf_backend_omit_section_dynsym \
5527 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5528 #define elf_backend_relocate_section \
5529 elf64_alpha_relocate_section
5530 #define elf_backend_finish_dynamic_symbol \
5531 elf64_alpha_finish_dynamic_symbol
5532 #define elf_backend_finish_dynamic_sections \
5533 elf64_alpha_finish_dynamic_sections
5534 #define bfd_elf64_bfd_final_link \
5535 elf64_alpha_final_link
5536 #define elf_backend_reloc_type_class \
5537 elf64_alpha_reloc_type_class
5539 #define elf_backend_can_gc_sections 1
5540 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5541 #define elf_backend_gc_sweep_hook elf64_alpha_gc_sweep_hook
5543 #define elf_backend_ecoff_debug_swap \
5544 &elf64_alpha_ecoff_debug_swap
5546 #define elf_backend_size_info \
5549 #define elf_backend_special_sections \
5550 elf64_alpha_special_sections
5552 /* A few constants that determine how the .plt section is set up. */
5553 #define elf_backend_want_got_plt 0
5554 #define elf_backend_plt_readonly 0
5555 #define elf_backend_want_plt_sym 1
5556 #define elf_backend_got_header_size 0
5558 #include "elf64-target.h"
5560 /* FreeBSD support. */
5562 #undef TARGET_LITTLE_SYM
5563 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5564 #undef TARGET_LITTLE_NAME
5565 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5567 #define ELF_OSABI ELFOSABI_FREEBSD
5569 /* The kernel recognizes executables as valid only if they carry a
5570 "FreeBSD" label in the ELF header. So we put this label on all
5571 executables and (for simplicity) also all other object files. */
5574 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5575 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5577 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5579 i_ehdrp = elf_elfheader (abfd);
5581 /* Put an ABI label supported by FreeBSD >= 4.1. */
5582 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5583 #ifdef OLD_FREEBSD_ABI_LABEL
5584 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5585 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5589 #undef elf_backend_post_process_headers
5590 #define elf_backend_post_process_headers \
5591 elf64_alpha_fbsd_post_process_headers
5594 #define elf64_bed elf64_alpha_fbsd_bed
5596 #include "elf64-target.h"