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)
2471 bfd *i, *got_list, *cur_got_obj = NULL;
2472 struct alpha_elf_link_hash_table * htab;
2474 htab = alpha_elf_hash_table (info);
2477 got_list = htab->got_list;
2479 /* On the first time through, pretend we have an existing got list
2480 consisting of all of the input files. */
2481 if (got_list == NULL)
2483 for (i = info->input_bfds; i ; i = i->link_next)
2487 if (! is_alpha_elf (i))
2490 this_got = alpha_elf_tdata (i)->gotobj;
2491 if (this_got == NULL)
2494 /* We are assuming no merging has yet occurred. */
2495 BFD_ASSERT (this_got == i);
2497 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2499 /* Yikes! A single object file has too many entries. */
2500 (*_bfd_error_handler)
2501 (_("%B: .got subsegment exceeds 64K (size %d)"),
2502 i, alpha_elf_tdata (this_got)->total_got_size);
2506 if (got_list == NULL)
2507 got_list = this_got;
2509 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2510 cur_got_obj = this_got;
2513 /* Strange degenerate case of no got references. */
2514 if (got_list == NULL)
2517 htab->got_list = got_list;
2520 cur_got_obj = got_list;
2521 if (cur_got_obj == NULL)
2524 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2527 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2529 elf64_alpha_merge_gots (cur_got_obj, i);
2531 alpha_elf_tdata(i)->got->size = 0;
2532 i = alpha_elf_tdata(i)->got_link_next;
2533 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2538 i = alpha_elf_tdata(i)->got_link_next;
2542 /* Once the gots have been merged, fill in the got offsets for
2543 everything therein. */
2544 elf64_alpha_calc_got_offsets (info);
2550 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2553 asection *splt = (asection *) data;
2554 struct alpha_elf_got_entry *gotent;
2555 bfd_boolean saw_one = FALSE;
2557 /* If we didn't need an entry before, we still don't. */
2558 if (!h->root.needs_plt)
2561 /* For each LITERAL got entry still in use, allocate a plt entry. */
2562 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2563 if (gotent->reloc_type == R_ALPHA_LITERAL
2564 && gotent->use_count > 0)
2566 if (splt->size == 0)
2567 splt->size = PLT_HEADER_SIZE;
2568 gotent->plt_offset = splt->size;
2569 splt->size += PLT_ENTRY_SIZE;
2573 /* If there weren't any, there's no longer a need for the PLT entry. */
2575 h->root.needs_plt = FALSE;
2580 /* Called from relax_section to rebuild the PLT in light of potential changes
2581 in the function's status. */
2584 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2586 asection *splt, *spltrel, *sgotplt;
2587 unsigned long entries;
2589 struct alpha_elf_link_hash_table * htab;
2591 htab = alpha_elf_hash_table (info);
2595 dynobj = elf_hash_table(info)->dynobj;
2596 splt = bfd_get_linker_section (dynobj, ".plt");
2602 alpha_elf_link_hash_traverse (htab,
2603 elf64_alpha_size_plt_section_1, splt);
2605 /* Every plt entry requires a JMP_SLOT relocation. */
2606 spltrel = bfd_get_linker_section (dynobj, ".rela.plt");
2610 if (elf64_alpha_use_secureplt)
2611 entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2613 entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2615 spltrel->size = entries * sizeof (Elf64_External_Rela);
2617 /* When using the secureplt, we need two words somewhere in the data
2618 segment for the dynamic linker to tell us where to go. This is the
2619 entire contents of the .got.plt section. */
2620 if (elf64_alpha_use_secureplt)
2622 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
2623 sgotplt->size = entries ? 16 : 0;
2628 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2629 struct bfd_link_info *info)
2632 struct alpha_elf_link_hash_table * htab;
2634 if (info->relocatable)
2637 htab = alpha_elf_hash_table (info);
2641 if (!elf64_alpha_size_got_sections (info))
2644 /* Allocate space for all of the .got subsections. */
2646 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2648 asection *s = alpha_elf_tdata(i)->got;
2651 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2652 if (s->contents == NULL)
2660 /* The number of dynamic relocations required by a static relocation. */
2663 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2667 /* May appear in GOT entries. */
2669 return (dynamic ? 2 : shared ? 1 : 0);
2670 case R_ALPHA_TLSLDM:
2672 case R_ALPHA_LITERAL:
2673 return dynamic || shared;
2674 case R_ALPHA_GOTTPREL:
2675 return dynamic || (shared && !pie);
2676 case R_ALPHA_GOTDTPREL:
2679 /* May appear in data sections. */
2680 case R_ALPHA_REFLONG:
2681 case R_ALPHA_REFQUAD:
2682 return dynamic || shared;
2683 case R_ALPHA_TPREL64:
2684 return dynamic || (shared && !pie);
2686 /* Everything else is illegal. We'll issue an error during
2687 relocate_section. */
2693 /* Work out the sizes of the dynamic relocation entries. */
2696 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2697 struct bfd_link_info *info)
2699 bfd_boolean dynamic;
2700 struct alpha_elf_reloc_entry *relent;
2701 unsigned long entries;
2703 /* If the symbol was defined as a common symbol in a regular object
2704 file, and there was no definition in any dynamic object, then the
2705 linker will have allocated space for the symbol in a common
2706 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2707 set. This is done for dynamic symbols in
2708 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2709 symbols, somehow. */
2710 if (!h->root.def_regular
2711 && h->root.ref_regular
2712 && !h->root.def_dynamic
2713 && (h->root.root.type == bfd_link_hash_defined
2714 || h->root.root.type == bfd_link_hash_defweak)
2715 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2716 h->root.def_regular = 1;
2718 /* If the symbol is dynamic, we'll need all the relocations in their
2719 natural form. If this is a shared object, and it has been forced
2720 local, we'll need the same number of RELATIVE relocations. */
2721 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2723 /* If the symbol is a hidden undefined weak, then we never have any
2724 relocations. Avoid the loop which may want to add RELATIVE relocs
2725 based on info->shared. */
2726 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2729 for (relent = h->reloc_entries; relent; relent = relent->next)
2731 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2732 info->shared, info->pie);
2735 relent->srel->size +=
2736 entries * sizeof (Elf64_External_Rela) * relent->count;
2737 if (relent->reltext)
2738 info->flags |= DT_TEXTREL;
2745 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2749 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2750 struct bfd_link_info *info)
2752 bfd_boolean dynamic;
2753 struct alpha_elf_got_entry *gotent;
2754 unsigned long entries;
2756 /* If we're using a plt for this symbol, then all of its relocations
2757 for its got entries go into .rela.plt. */
2758 if (h->root.needs_plt)
2761 /* If the symbol is dynamic, we'll need all the relocations in their
2762 natural form. If this is a shared object, and it has been forced
2763 local, we'll need the same number of RELATIVE relocations. */
2764 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2766 /* If the symbol is a hidden undefined weak, then we never have any
2767 relocations. Avoid the loop which may want to add RELATIVE relocs
2768 based on info->shared. */
2769 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2773 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2774 if (gotent->use_count > 0)
2775 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2776 info->shared, info->pie);
2780 bfd *dynobj = elf_hash_table(info)->dynobj;
2781 asection *srel = bfd_get_linker_section (dynobj, ".rela.got");
2782 BFD_ASSERT (srel != NULL);
2783 srel->size += sizeof (Elf64_External_Rela) * entries;
2789 /* Set the sizes of the dynamic relocation sections. */
2792 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2794 unsigned long entries;
2797 struct alpha_elf_link_hash_table * htab;
2799 htab = alpha_elf_hash_table (info);
2803 /* Shared libraries often require RELATIVE relocs, and some relocs
2804 require attention for the main application as well. */
2807 for (i = htab->got_list;
2808 i ; i = alpha_elf_tdata(i)->got_link_next)
2812 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2814 struct alpha_elf_got_entry **local_got_entries, *gotent;
2817 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2818 if (!local_got_entries)
2821 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2822 for (gotent = local_got_entries[k];
2823 gotent ; gotent = gotent->next)
2824 if (gotent->use_count > 0)
2825 entries += (alpha_dynamic_entries_for_reloc
2826 (gotent->reloc_type, 0, info->shared, info->pie));
2830 dynobj = elf_hash_table(info)->dynobj;
2831 srel = bfd_get_linker_section (dynobj, ".rela.got");
2834 BFD_ASSERT (entries == 0);
2837 srel->size = sizeof (Elf64_External_Rela) * entries;
2839 /* Now do the non-local symbols. */
2840 alpha_elf_link_hash_traverse (htab,
2841 elf64_alpha_size_rela_got_1, info);
2844 /* Set the sizes of the dynamic sections. */
2847 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2848 struct bfd_link_info *info)
2853 struct alpha_elf_link_hash_table * htab;
2855 htab = alpha_elf_hash_table (info);
2859 dynobj = elf_hash_table(info)->dynobj;
2860 BFD_ASSERT(dynobj != NULL);
2862 if (elf_hash_table (info)->dynamic_sections_created)
2864 /* Set the contents of the .interp section to the interpreter. */
2865 if (info->executable)
2867 s = bfd_get_linker_section (dynobj, ".interp");
2868 BFD_ASSERT (s != NULL);
2869 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2870 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2873 /* Now that we've seen all of the input files, we can decide which
2874 symbols need dynamic relocation entries and which don't. We've
2875 collected information in check_relocs that we can now apply to
2876 size the dynamic relocation sections. */
2877 alpha_elf_link_hash_traverse (htab,
2878 elf64_alpha_calc_dynrel_sizes, info);
2880 elf64_alpha_size_rela_got_section (info);
2881 elf64_alpha_size_plt_section (info);
2883 /* else we're not dynamic and by definition we don't need such things. */
2885 /* The check_relocs and adjust_dynamic_symbol entry points have
2886 determined the sizes of the various dynamic sections. Allocate
2889 for (s = dynobj->sections; s != NULL; s = s->next)
2893 if (!(s->flags & SEC_LINKER_CREATED))
2896 /* It's OK to base decisions on the section name, because none
2897 of the dynobj section names depend upon the input files. */
2898 name = bfd_get_section_name (dynobj, s);
2900 if (CONST_STRNEQ (name, ".rela"))
2904 if (strcmp (name, ".rela.plt") == 0)
2907 /* We use the reloc_count field as a counter if we need
2908 to copy relocs into the output file. */
2912 else if (! CONST_STRNEQ (name, ".got")
2913 && strcmp (name, ".plt") != 0
2914 && strcmp (name, ".dynbss") != 0)
2916 /* It's not one of our dynamic sections, so don't allocate space. */
2922 /* If we don't need this section, strip it from the output file.
2923 This is to handle .rela.bss and .rela.plt. We must create it
2924 in create_dynamic_sections, because it must be created before
2925 the linker maps input sections to output sections. The
2926 linker does that before adjust_dynamic_symbol is called, and
2927 it is that function which decides whether anything needs to
2928 go into these sections. */
2929 if (!CONST_STRNEQ (name, ".got"))
2930 s->flags |= SEC_EXCLUDE;
2932 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2934 /* Allocate memory for the section contents. */
2935 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2936 if (s->contents == NULL)
2941 if (elf_hash_table (info)->dynamic_sections_created)
2943 /* Add some entries to the .dynamic section. We fill in the
2944 values later, in elf64_alpha_finish_dynamic_sections, but we
2945 must add the entries now so that we get the correct size for
2946 the .dynamic section. The DT_DEBUG entry is filled in by the
2947 dynamic linker and used by the debugger. */
2948 #define add_dynamic_entry(TAG, VAL) \
2949 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2951 if (info->executable)
2953 if (!add_dynamic_entry (DT_DEBUG, 0))
2959 if (!add_dynamic_entry (DT_PLTGOT, 0)
2960 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2961 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2962 || !add_dynamic_entry (DT_JMPREL, 0))
2965 if (elf64_alpha_use_secureplt
2966 && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2970 if (!add_dynamic_entry (DT_RELA, 0)
2971 || !add_dynamic_entry (DT_RELASZ, 0)
2972 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2975 if (info->flags & DF_TEXTREL)
2977 if (!add_dynamic_entry (DT_TEXTREL, 0))
2981 #undef add_dynamic_entry
2986 /* These functions do relaxation for Alpha ELF.
2988 Currently I'm only handling what I can do with existing compiler
2989 and assembler support, which means no instructions are removed,
2990 though some may be nopped. At this time GCC does not emit enough
2991 information to do all of the relaxing that is possible. It will
2992 take some not small amount of work for that to happen.
2994 There are a couple of interesting papers that I once read on this
2995 subject, that I cannot find references to at the moment, that
2996 related to Alpha in particular. They are by David Wall, then of
2999 struct alpha_relax_info
3004 Elf_Internal_Shdr *symtab_hdr;
3005 Elf_Internal_Rela *relocs, *relend;
3006 struct bfd_link_info *link_info;
3010 struct alpha_elf_link_hash_entry *h;
3011 struct alpha_elf_got_entry **first_gotent;
3012 struct alpha_elf_got_entry *gotent;
3013 bfd_boolean changed_contents;
3014 bfd_boolean changed_relocs;
3015 unsigned char other;
3018 static Elf_Internal_Rela *
3019 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
3020 Elf_Internal_Rela *relend,
3021 bfd_vma offset, int type)
3023 while (rel < relend)
3025 if (rel->r_offset == offset
3026 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
3034 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3035 Elf_Internal_Rela *irel, unsigned long r_type)
3038 bfd_signed_vma disp;
3040 /* Get the instruction. */
3041 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3043 if (insn >> 26 != OP_LDQ)
3045 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3046 ((*_bfd_error_handler)
3047 ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
3048 info->abfd, info->sec,
3049 (unsigned long) irel->r_offset, howto->name));
3053 /* Can't relax dynamic symbols. */
3054 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3057 /* Can't use local-exec relocations in shared libraries. */
3058 if (r_type == R_ALPHA_GOTTPREL
3059 && (info->link_info->shared && !info->link_info->pie))
3062 if (r_type == R_ALPHA_LITERAL)
3064 /* Look for nice constant addresses. This includes the not-uncommon
3065 special case of 0 for undefweak symbols. */
3066 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3067 || (!info->link_info->shared
3068 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3071 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3072 insn |= (symval & 0xffff);
3073 r_type = R_ALPHA_NONE;
3077 disp = symval - info->gp;
3078 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3079 r_type = R_ALPHA_GPREL16;
3084 bfd_vma dtp_base, tp_base;
3086 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3087 dtp_base = alpha_get_dtprel_base (info->link_info);
3088 tp_base = alpha_get_tprel_base (info->link_info);
3089 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3091 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3095 case R_ALPHA_GOTDTPREL:
3096 r_type = R_ALPHA_DTPREL16;
3098 case R_ALPHA_GOTTPREL:
3099 r_type = R_ALPHA_TPREL16;
3107 if (disp < -0x8000 || disp >= 0x8000)
3110 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3111 info->changed_contents = TRUE;
3113 /* Reduce the use count on this got entry by one, possibly
3115 if (--info->gotent->use_count == 0)
3117 int sz = alpha_got_entry_size (r_type);
3118 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3120 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3123 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3124 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3125 info->changed_relocs = TRUE;
3127 /* ??? Search forward through this basic block looking for insns
3128 that use the target register. Stop after an insn modifying the
3129 register is seen, or after a branch or call.
3131 Any such memory load insn may be substituted by a load directly
3132 off the GP. This allows the memory load insn to be issued before
3133 the calculated GP register would otherwise be ready.
3135 Any such jsr insn can be replaced by a bsr if it is in range.
3137 This would mean that we'd have to _add_ relocations, the pain of
3138 which gives one pause. */
3144 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3146 /* If the function has the same gp, and we can identify that the
3147 function does not use its function pointer, we can eliminate the
3150 /* If the symbol is marked NOPV, we are being told the function never
3151 needs its procedure value. */
3152 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3155 /* If the symbol is marked STD_GP, we are being told the function does
3156 a normal ldgp in the first two words. */
3157 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3160 /* Otherwise, we may be able to identify a GP load in the first two
3161 words, which we can then skip. */
3164 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3167 /* Load the relocations from the section that the target symbol is in. */
3168 if (info->sec == info->tsec)
3170 tsec_relocs = info->relocs;
3171 tsec_relend = info->relend;
3176 tsec_relocs = (_bfd_elf_link_read_relocs
3177 (info->abfd, info->tsec, NULL,
3178 (Elf_Internal_Rela *) NULL,
3179 info->link_info->keep_memory));
3180 if (tsec_relocs == NULL)
3182 tsec_relend = tsec_relocs + info->tsec->reloc_count;
3183 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
3186 /* Recover the symbol's offset within the section. */
3187 ofs = (symval - info->tsec->output_section->vma
3188 - info->tsec->output_offset);
3190 /* Look for a GPDISP reloc. */
3191 gpdisp = (elf64_alpha_find_reloc_at_ofs
3192 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3194 if (!gpdisp || gpdisp->r_addend != 4)
3204 /* We've now determined that we can skip an initial gp load. Verify
3205 that the call and the target use the same gp. */
3206 if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3207 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3214 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3215 bfd_vma symval, Elf_Internal_Rela *irel)
3217 Elf_Internal_Rela *urel, *irelend = info->relend;
3218 int flags, count, i;
3219 bfd_signed_vma disp;
3222 bfd_boolean lit_reused = FALSE;
3223 bfd_boolean all_optimized = TRUE;
3224 unsigned int lit_insn;
3226 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3227 if (lit_insn >> 26 != OP_LDQ)
3229 ((*_bfd_error_handler)
3230 ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
3231 info->abfd, info->sec,
3232 (unsigned long) irel->r_offset));
3236 /* Can't relax dynamic symbols. */
3237 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3240 /* Summarize how this particular LITERAL is used. */
3241 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
3243 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
3245 if (urel->r_addend <= 6)
3246 flags |= 1 << urel->r_addend;
3249 /* A little preparation for the loop... */
3250 disp = symval - info->gp;
3252 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
3256 bfd_signed_vma xdisp;
3258 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
3260 switch (urel->r_addend)
3262 case LITUSE_ALPHA_ADDR:
3264 /* This type is really just a placeholder to note that all
3265 uses cannot be optimized, but to still allow some. */
3266 all_optimized = FALSE;
3269 case LITUSE_ALPHA_BASE:
3270 /* We can always optimize 16-bit displacements. */
3272 /* Extract the displacement from the instruction, sign-extending
3273 it if necessary, then test whether it is within 16 or 32 bits
3274 displacement from GP. */
3275 insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3277 xdisp = disp + insn_disp;
3278 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3279 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3280 && xdisp < 0x7fff8000);
3284 /* Take the op code and dest from this insn, take the base
3285 register from the literal insn. Leave the offset alone. */
3286 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3287 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3289 urel->r_addend = irel->r_addend;
3290 info->changed_relocs = TRUE;
3292 bfd_put_32 (info->abfd, (bfd_vma) insn,
3293 info->contents + urel->r_offset);
3294 info->changed_contents = TRUE;
3297 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3298 else if (fits32 && !(flags & ~6))
3300 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3302 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3304 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3305 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
3306 info->contents + irel->r_offset);
3308 info->changed_contents = TRUE;
3310 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3312 urel->r_addend = irel->r_addend;
3313 info->changed_relocs = TRUE;
3316 all_optimized = FALSE;
3319 case LITUSE_ALPHA_BYTOFF:
3320 /* We can always optimize byte instructions. */
3322 /* FIXME: sanity check the insn for byte op. Check that the
3323 literal dest reg is indeed Rb in the byte insn. */
3325 insn &= ~ (unsigned) 0x001ff000;
3326 insn |= ((symval & 7) << 13) | 0x1000;
3328 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3330 info->changed_relocs = TRUE;
3332 bfd_put_32 (info->abfd, (bfd_vma) insn,
3333 info->contents + urel->r_offset);
3334 info->changed_contents = TRUE;
3337 case LITUSE_ALPHA_JSR:
3338 case LITUSE_ALPHA_TLSGD:
3339 case LITUSE_ALPHA_TLSLDM:
3340 case LITUSE_ALPHA_JSRDIRECT:
3342 bfd_vma optdest, org;
3343 bfd_signed_vma odisp;
3345 /* For undefined weak symbols, we're mostly interested in getting
3346 rid of the got entry whenever possible, so optimize this to a
3347 use of the zero register. */
3348 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3351 bfd_put_32 (info->abfd, (bfd_vma) insn,
3352 info->contents + urel->r_offset);
3354 info->changed_contents = TRUE;
3358 /* If not zero, place to jump without needing pv. */
3359 optdest = elf64_alpha_relax_opt_call (info, symval);
3360 org = (info->sec->output_section->vma
3361 + info->sec->output_offset
3362 + urel->r_offset + 4);
3363 odisp = (optdest ? optdest : symval) - org;
3365 if (odisp >= -0x400000 && odisp < 0x400000)
3367 Elf_Internal_Rela *xrel;
3369 /* Preserve branch prediction call stack when possible. */
3370 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3371 insn = (OP_BSR << 26) | (insn & 0x03e00000);
3373 insn = (OP_BR << 26) | (insn & 0x03e00000);
3375 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3377 urel->r_addend = irel->r_addend;
3380 urel->r_addend += optdest - symval;
3382 all_optimized = FALSE;
3384 bfd_put_32 (info->abfd, (bfd_vma) insn,
3385 info->contents + urel->r_offset);
3387 /* Kill any HINT reloc that might exist for this insn. */
3388 xrel = (elf64_alpha_find_reloc_at_ofs
3389 (info->relocs, info->relend, urel->r_offset,
3392 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3394 info->changed_contents = TRUE;
3395 info->changed_relocs = TRUE;
3398 all_optimized = FALSE;
3400 /* Even if the target is not in range for a direct branch,
3401 if we share a GP, we can eliminate the gp reload. */
3404 Elf_Internal_Rela *gpdisp
3405 = (elf64_alpha_find_reloc_at_ofs
3406 (info->relocs, irelend, urel->r_offset + 4,
3410 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
3411 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3412 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
3413 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
3415 /* Verify that the instruction is "ldah $29,0($26)".
3416 Consider a function that ends in a noreturn call,
3417 and that the next function begins with an ldgp,
3418 and that by accident there is no padding between.
3419 In that case the insn would use $27 as the base. */
3420 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3422 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
3423 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
3425 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3426 info->changed_contents = TRUE;
3427 info->changed_relocs = TRUE;
3436 /* If all cases were optimized, we can reduce the use count on this
3437 got entry by one, possibly eliminating it. */
3440 if (--info->gotent->use_count == 0)
3442 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3443 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3445 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3448 /* If the literal instruction is no longer needed (it may have been
3449 reused. We can eliminate it. */
3450 /* ??? For now, I don't want to deal with compacting the section,
3451 so just nop it out. */
3454 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3455 info->changed_relocs = TRUE;
3457 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
3458 info->contents + irel->r_offset);
3459 info->changed_contents = TRUE;
3465 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3469 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3470 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3473 unsigned int insn, tlsgd_reg;
3474 Elf_Internal_Rela *gpdisp, *hint;
3475 bfd_boolean dynamic, use_gottprel;
3476 unsigned long new_symndx;
3478 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3480 /* If a TLS symbol is accessed using IE at least once, there is no point
3481 to use dynamic model for it. */
3482 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3485 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3486 then we might as well relax to IE. */
3487 else if (info->link_info->shared && !dynamic
3488 && (info->link_info->flags & DF_STATIC_TLS))
3491 /* Otherwise we must be building an executable to do anything. */
3492 else if (info->link_info->shared)
3495 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3496 the matching LITUSE_TLS relocations. */
3497 if (irel + 2 >= info->relend)
3499 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3500 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3501 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3504 /* There must be a GPDISP relocation positioned immediately after the
3505 LITUSE relocation. */
3506 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3507 irel[2].r_offset + 4, R_ALPHA_GPDISP);
3511 pos[0] = info->contents + irel[0].r_offset;
3512 pos[1] = info->contents + irel[1].r_offset;
3513 pos[2] = info->contents + irel[2].r_offset;
3514 pos[3] = info->contents + gpdisp->r_offset;
3515 pos[4] = pos[3] + gpdisp->r_addend;
3517 /* Beware of the compiler hoisting part of the sequence out a loop
3518 and adjusting the destination register for the TLSGD insn. If this
3519 happens, there will be a move into $16 before the JSR insn, so only
3520 transformations of the first insn pair should use this register. */
3521 tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3522 tlsgd_reg = (tlsgd_reg >> 21) & 31;
3524 /* Generally, the positions are not allowed to be out of order, lest the
3525 modified insn sequence have different register lifetimes. We can make
3526 an exception when pos 1 is adjacent to pos 0. */
3527 if (pos[1] + 4 == pos[0])
3529 bfd_byte *tmp = pos[0];
3533 if (pos[1] >= pos[2] || pos[2] >= pos[3])
3536 /* Reduce the use count on the LITERAL relocation. Do this before we
3537 smash the symndx when we adjust the relocations below. */
3539 struct alpha_elf_got_entry *lit_gotent;
3540 struct alpha_elf_link_hash_entry *lit_h;
3543 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3544 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3545 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3547 while (lit_h->root.root.type == bfd_link_hash_indirect
3548 || lit_h->root.root.type == bfd_link_hash_warning)
3549 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3551 for (lit_gotent = lit_h->got_entries; lit_gotent ;
3552 lit_gotent = lit_gotent->next)
3553 if (lit_gotent->gotobj == info->gotobj
3554 && lit_gotent->reloc_type == R_ALPHA_LITERAL
3555 && lit_gotent->addend == irel[1].r_addend)
3557 BFD_ASSERT (lit_gotent);
3559 if (--lit_gotent->use_count == 0)
3561 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3562 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3568 lda $16,x($gp) !tlsgd!1
3569 ldq $27,__tls_get_addr($gp) !literal!1
3570 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3571 ldah $29,0($26) !gpdisp!2
3572 lda $29,0($29) !gpdisp!2
3574 ldq $16,x($gp) !gottprel
3579 or the first pair to
3580 lda $16,x($gp) !tprel
3583 ldah $16,x($gp) !tprelhi
3584 lda $16,x($16) !tprello
3588 use_gottprel = FALSE;
3589 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3591 /* Some compilers warn about a Boolean-looking expression being
3592 used in a switch. The explicit cast silences them. */
3593 switch ((int) (!dynamic && !info->link_info->shared))
3598 bfd_signed_vma disp;
3600 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3601 tp_base = alpha_get_tprel_base (info->link_info);
3602 disp = symval - tp_base;
3604 if (disp >= -0x8000 && disp < 0x8000)
3606 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3607 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3608 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3610 irel[0].r_offset = pos[0] - info->contents;
3611 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3612 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3615 else if (disp >= -(bfd_signed_vma) 0x80000000
3616 && disp < (bfd_signed_vma) 0x7fff8000
3617 && pos[0] + 4 == pos[1])
3619 insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3620 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3621 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3622 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3624 irel[0].r_offset = pos[0] - info->contents;
3625 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3626 irel[1].r_offset = pos[1] - info->contents;
3627 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3634 use_gottprel = TRUE;
3636 insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3637 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3638 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3640 irel[0].r_offset = pos[0] - info->contents;
3641 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3642 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3646 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3648 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3649 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3651 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3653 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3654 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3656 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3657 irel[2].r_offset, R_ALPHA_HINT);
3659 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3661 info->changed_contents = TRUE;
3662 info->changed_relocs = TRUE;
3664 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3665 if (--info->gotent->use_count == 0)
3667 int sz = alpha_got_entry_size (info->gotent->reloc_type);
3668 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3670 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3673 /* If we've switched to a GOTTPREL relocation, increment the reference
3674 count on that got entry. */
3677 struct alpha_elf_got_entry *tprel_gotent;
3679 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3680 tprel_gotent = tprel_gotent->next)
3681 if (tprel_gotent->gotobj == info->gotobj
3682 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3683 && tprel_gotent->addend == irel->r_addend)
3686 tprel_gotent->use_count++;
3689 if (info->gotent->use_count == 0)
3690 tprel_gotent = info->gotent;
3693 tprel_gotent = (struct alpha_elf_got_entry *)
3694 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3698 tprel_gotent->next = *info->first_gotent;
3699 *info->first_gotent = tprel_gotent;
3701 tprel_gotent->gotobj = info->gotobj;
3702 tprel_gotent->addend = irel->r_addend;
3703 tprel_gotent->got_offset = -1;
3704 tprel_gotent->reloc_done = 0;
3705 tprel_gotent->reloc_xlated = 0;
3708 tprel_gotent->use_count = 1;
3709 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3717 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3718 struct bfd_link_info *link_info, bfd_boolean *again)
3720 Elf_Internal_Shdr *symtab_hdr;
3721 Elf_Internal_Rela *internal_relocs;
3722 Elf_Internal_Rela *irel, *irelend;
3723 Elf_Internal_Sym *isymbuf = NULL;
3724 struct alpha_elf_got_entry **local_got_entries;
3725 struct alpha_relax_info info;
3726 struct alpha_elf_link_hash_table * htab;
3728 htab = alpha_elf_hash_table (link_info);
3732 /* There's nothing to change, yet. */
3735 if (link_info->relocatable
3736 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3737 != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3738 || sec->reloc_count == 0)
3741 BFD_ASSERT (is_alpha_elf (abfd));
3743 /* Make sure our GOT and PLT tables are up-to-date. */
3744 if (htab->relax_trip != link_info->relax_trip)
3746 htab->relax_trip = link_info->relax_trip;
3748 /* This should never fail after the initial round, since the only
3749 error is GOT overflow, and relaxation only shrinks the table. */
3750 if (!elf64_alpha_size_got_sections (link_info))
3752 if (elf_hash_table (link_info)->dynamic_sections_created)
3754 elf64_alpha_size_plt_section (link_info);
3755 elf64_alpha_size_rela_got_section (link_info);
3759 symtab_hdr = &elf_symtab_hdr (abfd);
3760 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3762 /* Load the relocations for this section. */
3763 internal_relocs = (_bfd_elf_link_read_relocs
3764 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3765 link_info->keep_memory));
3766 if (internal_relocs == NULL)
3769 memset(&info, 0, sizeof (info));
3772 info.link_info = link_info;
3773 info.symtab_hdr = symtab_hdr;
3774 info.relocs = internal_relocs;
3775 info.relend = irelend = internal_relocs + sec->reloc_count;
3777 /* Find the GP for this object. Do not store the result back via
3778 _bfd_set_gp_value, since this could change again before final. */
3779 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3782 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3783 info.gp = (sgot->output_section->vma
3784 + sgot->output_offset
3788 /* Get the section contents. */
3789 if (elf_section_data (sec)->this_hdr.contents != NULL)
3790 info.contents = elf_section_data (sec)->this_hdr.contents;
3793 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3797 for (irel = internal_relocs; irel < irelend; irel++)
3800 struct alpha_elf_got_entry *gotent;
3801 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3802 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3804 /* Early exit for unhandled or unrelaxable relocations. */
3807 case R_ALPHA_LITERAL:
3808 case R_ALPHA_GPRELHIGH:
3809 case R_ALPHA_GPRELLOW:
3810 case R_ALPHA_GOTDTPREL:
3811 case R_ALPHA_GOTTPREL:
3815 case R_ALPHA_TLSLDM:
3816 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3817 reloc to the STN_UNDEF (0) symbol so that they all match. */
3818 r_symndx = STN_UNDEF;
3825 /* Get the value of the symbol referred to by the reloc. */
3826 if (r_symndx < symtab_hdr->sh_info)
3828 /* A local symbol. */
3829 Elf_Internal_Sym *isym;
3831 /* Read this BFD's local symbols. */
3832 if (isymbuf == NULL)
3834 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3835 if (isymbuf == NULL)
3836 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3837 symtab_hdr->sh_info, 0,
3839 if (isymbuf == NULL)
3843 isym = isymbuf + r_symndx;
3845 /* Given the symbol for a TLSLDM reloc is ignored, this also
3846 means forcing the symbol value to the tp base. */
3847 if (r_type == R_ALPHA_TLSLDM)
3849 info.tsec = bfd_abs_section_ptr;
3850 symval = alpha_get_tprel_base (info.link_info);
3854 symval = isym->st_value;
3855 if (isym->st_shndx == SHN_UNDEF)
3857 else if (isym->st_shndx == SHN_ABS)
3858 info.tsec = bfd_abs_section_ptr;
3859 else if (isym->st_shndx == SHN_COMMON)
3860 info.tsec = bfd_com_section_ptr;
3862 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3866 info.other = isym->st_other;
3867 if (local_got_entries)
3868 info.first_gotent = &local_got_entries[r_symndx];
3871 info.first_gotent = &info.gotent;
3878 struct alpha_elf_link_hash_entry *h;
3880 indx = r_symndx - symtab_hdr->sh_info;
3881 h = alpha_elf_sym_hashes (abfd)[indx];
3882 BFD_ASSERT (h != NULL);
3884 while (h->root.root.type == bfd_link_hash_indirect
3885 || h->root.root.type == bfd_link_hash_warning)
3886 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3888 /* If the symbol is undefined, we can't do anything with it. */
3889 if (h->root.root.type == bfd_link_hash_undefined)
3892 /* If the symbol isn't defined in the current module,
3893 again we can't do anything. */
3894 if (h->root.root.type == bfd_link_hash_undefweak)
3896 info.tsec = bfd_abs_section_ptr;
3899 else if (!h->root.def_regular)
3901 /* Except for TLSGD relocs, which can sometimes be
3902 relaxed to GOTTPREL relocs. */
3903 if (r_type != R_ALPHA_TLSGD)
3905 info.tsec = bfd_abs_section_ptr;
3910 info.tsec = h->root.root.u.def.section;
3911 symval = h->root.root.u.def.value;
3915 info.other = h->root.other;
3916 info.first_gotent = &h->got_entries;
3919 /* Search for the got entry to be used by this relocation. */
3920 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3921 if (gotent->gotobj == info.gotobj
3922 && gotent->reloc_type == r_type
3923 && gotent->addend == irel->r_addend)
3925 info.gotent = gotent;
3927 symval += info.tsec->output_section->vma + info.tsec->output_offset;
3928 symval += irel->r_addend;
3932 case R_ALPHA_LITERAL:
3933 BFD_ASSERT(info.gotent != NULL);
3935 /* If there exist LITUSE relocations immediately following, this
3936 opens up all sorts of interesting optimizations, because we
3937 now know every location that this address load is used. */
3938 if (irel+1 < irelend
3939 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
3941 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
3946 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3951 case R_ALPHA_GOTDTPREL:
3952 case R_ALPHA_GOTTPREL:
3953 BFD_ASSERT(info.gotent != NULL);
3954 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3959 case R_ALPHA_TLSLDM:
3960 BFD_ASSERT(info.gotent != NULL);
3961 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
3962 r_type == R_ALPHA_TLSGD))
3969 && symtab_hdr->contents != (unsigned char *) isymbuf)
3971 if (!link_info->keep_memory)
3975 /* Cache the symbols for elf_link_input_bfd. */
3976 symtab_hdr->contents = (unsigned char *) isymbuf;
3980 if (info.contents != NULL
3981 && elf_section_data (sec)->this_hdr.contents != info.contents)
3983 if (!info.changed_contents && !link_info->keep_memory)
3984 free (info.contents);
3987 /* Cache the section contents for elf_link_input_bfd. */
3988 elf_section_data (sec)->this_hdr.contents = info.contents;
3992 if (elf_section_data (sec)->relocs != internal_relocs)
3994 if (!info.changed_relocs)
3995 free (internal_relocs);
3997 elf_section_data (sec)->relocs = internal_relocs;
4000 *again = info.changed_contents || info.changed_relocs;
4006 && symtab_hdr->contents != (unsigned char *) isymbuf)
4008 if (info.contents != NULL
4009 && elf_section_data (sec)->this_hdr.contents != info.contents)
4010 free (info.contents);
4011 if (internal_relocs != NULL
4012 && elf_section_data (sec)->relocs != internal_relocs)
4013 free (internal_relocs);
4017 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4018 into the next available slot in SREL. */
4021 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4022 asection *sec, asection *srel, bfd_vma offset,
4023 long dynindx, long rtype, bfd_vma addend)
4025 Elf_Internal_Rela outrel;
4028 BFD_ASSERT (srel != NULL);
4030 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4031 outrel.r_addend = addend;
4033 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4034 if ((offset | 1) != (bfd_vma) -1)
4035 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4037 memset (&outrel, 0, sizeof (outrel));
4039 loc = srel->contents;
4040 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4041 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4042 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4045 /* Relocate an Alpha ELF section for a relocatable link.
4047 We don't have to change anything unless the reloc is against a section
4048 symbol, in which case we have to adjust according to where the section
4049 symbol winds up in the output section. */
4052 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4053 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4054 bfd *input_bfd, asection *input_section,
4055 bfd_byte *contents ATTRIBUTE_UNUSED,
4056 Elf_Internal_Rela *relocs,
4057 Elf_Internal_Sym *local_syms,
4058 asection **local_sections)
4060 unsigned long symtab_hdr_sh_info;
4061 Elf_Internal_Rela *rel;
4062 Elf_Internal_Rela *relend;
4063 struct elf_link_hash_entry **sym_hashes;
4064 bfd_boolean ret_val = TRUE;
4066 symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4067 sym_hashes = elf_sym_hashes (input_bfd);
4069 relend = relocs + input_section->reloc_count;
4070 for (rel = relocs; rel < relend; rel++)
4072 unsigned long r_symndx;
4073 Elf_Internal_Sym *sym;
4075 unsigned long r_type;
4077 r_type = ELF64_R_TYPE (rel->r_info);
4078 if (r_type >= R_ALPHA_max)
4080 (*_bfd_error_handler)
4081 (_("%B: unknown relocation type %d"),
4082 input_bfd, (int) r_type);
4083 bfd_set_error (bfd_error_bad_value);
4088 /* The symbol associated with GPDISP and LITUSE is
4089 immaterial. Only the addend is significant. */
4090 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4093 r_symndx = ELF64_R_SYM (rel->r_info);
4094 if (r_symndx < symtab_hdr_sh_info)
4096 sym = local_syms + r_symndx;
4097 sec = local_sections[r_symndx];
4101 struct elf_link_hash_entry *h;
4103 h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4105 while (h->root.type == bfd_link_hash_indirect
4106 || h->root.type == bfd_link_hash_warning)
4107 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4109 if (h->root.type != bfd_link_hash_defined
4110 && h->root.type != bfd_link_hash_defweak)
4114 sec = h->root.u.def.section;
4117 if (sec != NULL && discarded_section (sec))
4118 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4120 elf64_alpha_howto_table + r_type, 0,
4123 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4124 rel->r_addend += sec->output_offset;
4130 /* Relocate an Alpha ELF section. */
4133 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4134 bfd *input_bfd, asection *input_section,
4135 bfd_byte *contents, Elf_Internal_Rela *relocs,
4136 Elf_Internal_Sym *local_syms,
4137 asection **local_sections)
4139 Elf_Internal_Shdr *symtab_hdr;
4140 Elf_Internal_Rela *rel;
4141 Elf_Internal_Rela *relend;
4142 asection *sgot, *srel, *srelgot;
4143 bfd *dynobj, *gotobj;
4144 bfd_vma gp, tp_base, dtp_base;
4145 struct alpha_elf_got_entry **local_got_entries;
4146 bfd_boolean ret_val;
4148 BFD_ASSERT (is_alpha_elf (input_bfd));
4150 /* Handle relocatable links with a smaller loop. */
4151 if (info->relocatable)
4152 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4153 input_section, contents, relocs,
4154 local_syms, local_sections);
4156 /* This is a final link. */
4160 symtab_hdr = &elf_symtab_hdr (input_bfd);
4162 dynobj = elf_hash_table (info)->dynobj;
4164 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
4168 if (input_section->flags & SEC_ALLOC)
4170 const char *section_name;
4171 section_name = (bfd_elf_string_from_elf_section
4172 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4173 _bfd_elf_single_rel_hdr (input_section)->sh_name));
4174 BFD_ASSERT(section_name != NULL);
4175 srel = bfd_get_linker_section (dynobj, section_name);
4180 /* Find the gp value for this input bfd. */
4181 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4184 sgot = alpha_elf_tdata (gotobj)->got;
4185 gp = _bfd_get_gp_value (gotobj);
4188 gp = (sgot->output_section->vma
4189 + sgot->output_offset
4191 _bfd_set_gp_value (gotobj, gp);
4200 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4202 if (elf_hash_table (info)->tls_sec != NULL)
4204 dtp_base = alpha_get_dtprel_base (info);
4205 tp_base = alpha_get_tprel_base (info);
4208 dtp_base = tp_base = 0;
4210 relend = relocs + input_section->reloc_count;
4211 for (rel = relocs; rel < relend; rel++)
4213 struct alpha_elf_link_hash_entry *h = NULL;
4214 struct alpha_elf_got_entry *gotent;
4215 bfd_reloc_status_type r;
4216 reloc_howto_type *howto;
4217 unsigned long r_symndx;
4218 Elf_Internal_Sym *sym = NULL;
4219 asection *sec = NULL;
4222 bfd_boolean dynamic_symbol_p;
4223 bfd_boolean unresolved_reloc = FALSE;
4224 bfd_boolean undef_weak_ref = FALSE;
4225 unsigned long r_type;
4227 r_type = ELF64_R_TYPE(rel->r_info);
4228 if (r_type >= R_ALPHA_max)
4230 (*_bfd_error_handler)
4231 (_("%B: unknown relocation type %d"),
4232 input_bfd, (int) r_type);
4233 bfd_set_error (bfd_error_bad_value);
4238 howto = elf64_alpha_howto_table + r_type;
4239 r_symndx = ELF64_R_SYM(rel->r_info);
4241 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4242 reloc to the STN_UNDEF (0) symbol so that they all match. */
4243 if (r_type == R_ALPHA_TLSLDM)
4244 r_symndx = STN_UNDEF;
4246 if (r_symndx < symtab_hdr->sh_info)
4249 sym = local_syms + r_symndx;
4250 sec = local_sections[r_symndx];
4252 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4254 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4255 this is hackery from relax_section. Force the value to
4256 be the tls module base. */
4257 if (r_symndx == STN_UNDEF
4258 && (r_type == R_ALPHA_TLSLDM
4259 || r_type == R_ALPHA_GOTTPREL
4260 || r_type == R_ALPHA_TPREL64
4261 || r_type == R_ALPHA_TPRELHI
4262 || r_type == R_ALPHA_TPRELLO
4263 || r_type == R_ALPHA_TPREL16))
4266 if (local_got_entries)
4267 gotent = local_got_entries[r_symndx];
4271 /* Need to adjust local GOT entries' addends for SEC_MERGE
4272 unless it has been done already. */
4273 if ((sec->flags & SEC_MERGE)
4274 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4275 && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4277 && !gotent->reloc_xlated)
4279 struct alpha_elf_got_entry *ent;
4281 for (ent = gotent; ent; ent = ent->next)
4283 ent->reloc_xlated = 1;
4284 if (ent->use_count == 0)
4288 _bfd_merged_section_offset (output_bfd, &msec,
4289 elf_section_data (sec)->
4291 sym->st_value + ent->addend);
4292 ent->addend -= sym->st_value;
4293 ent->addend += msec->output_section->vma
4294 + msec->output_offset
4295 - sec->output_section->vma
4296 - sec->output_offset;
4300 dynamic_symbol_p = FALSE;
4304 bfd_boolean warned, ignored;
4305 struct elf_link_hash_entry *hh;
4306 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4308 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4309 r_symndx, symtab_hdr, sym_hashes,
4311 unresolved_reloc, warned, ignored);
4317 && ! unresolved_reloc
4318 && hh->root.type == bfd_link_hash_undefweak)
4319 undef_weak_ref = TRUE;
4321 h = (struct alpha_elf_link_hash_entry *) hh;
4322 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4323 gotent = h->got_entries;
4326 if (sec != NULL && discarded_section (sec))
4327 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4328 rel, 1, relend, howto, 0, contents);
4330 addend = rel->r_addend;
4333 /* Search for the proper got entry. */
4334 for (; gotent ; gotent = gotent->next)
4335 if (gotent->gotobj == gotobj
4336 && gotent->reloc_type == r_type
4337 && gotent->addend == addend)
4342 case R_ALPHA_GPDISP:
4344 bfd_byte *p_ldah, *p_lda;
4346 BFD_ASSERT(gp != 0);
4348 value = (input_section->output_section->vma
4349 + input_section->output_offset
4352 p_ldah = contents + rel->r_offset;
4353 p_lda = p_ldah + rel->r_addend;
4355 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4360 case R_ALPHA_LITERAL:
4361 BFD_ASSERT(sgot != NULL);
4362 BFD_ASSERT(gp != 0);
4363 BFD_ASSERT(gotent != NULL);
4364 BFD_ASSERT(gotent->use_count >= 1);
4366 if (!gotent->reloc_done)
4368 gotent->reloc_done = 1;
4370 bfd_put_64 (output_bfd, value,
4371 sgot->contents + gotent->got_offset);
4373 /* If the symbol has been forced local, output a
4374 RELATIVE reloc, otherwise it will be handled in
4375 finish_dynamic_symbol. */
4376 if (info->shared && !dynamic_symbol_p && !undef_weak_ref)
4377 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4378 gotent->got_offset, 0,
4379 R_ALPHA_RELATIVE, value);
4382 value = (sgot->output_section->vma
4383 + sgot->output_offset
4384 + gotent->got_offset);
4388 case R_ALPHA_GPREL32:
4389 case R_ALPHA_GPREL16:
4390 case R_ALPHA_GPRELLOW:
4391 if (dynamic_symbol_p)
4393 (*_bfd_error_handler)
4394 (_("%B: gp-relative relocation against dynamic symbol %s"),
4395 input_bfd, h->root.root.root.string);
4398 BFD_ASSERT(gp != 0);
4402 case R_ALPHA_GPRELHIGH:
4403 if (dynamic_symbol_p)
4405 (*_bfd_error_handler)
4406 (_("%B: gp-relative relocation against dynamic symbol %s"),
4407 input_bfd, h->root.root.root.string);
4410 BFD_ASSERT(gp != 0);
4412 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4416 /* A call to a dynamic symbol is definitely out of range of
4417 the 16-bit displacement. Don't bother writing anything. */
4418 if (dynamic_symbol_p)
4423 /* The regular PC-relative stuff measures from the start of
4424 the instruction rather than the end. */
4428 case R_ALPHA_BRADDR:
4429 if (dynamic_symbol_p)
4431 (*_bfd_error_handler)
4432 (_("%B: pc-relative relocation against dynamic symbol %s"),
4433 input_bfd, h->root.root.root.string);
4436 /* The regular PC-relative stuff measures from the start of
4437 the instruction rather than the end. */
4446 /* The regular PC-relative stuff measures from the start of
4447 the instruction rather than the end. */
4450 /* The source and destination gp must be the same. Note that
4451 the source will always have an assigned gp, since we forced
4452 one in check_relocs, but that the destination may not, as
4453 it might not have had any relocations at all. Also take
4454 care not to crash if H is an undefined symbol. */
4455 if (h != NULL && sec != NULL
4456 && alpha_elf_tdata (sec->owner)->gotobj
4457 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4459 (*_bfd_error_handler)
4460 (_("%B: change in gp: BRSGP %s"),
4461 input_bfd, h->root.root.root.string);
4465 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4467 other = h->root.other;
4469 other = sym->st_other;
4470 switch (other & STO_ALPHA_STD_GPLOAD)
4472 case STO_ALPHA_NOPV:
4474 case STO_ALPHA_STD_GPLOAD:
4479 name = h->root.root.root.string;
4482 name = (bfd_elf_string_from_elf_section
4483 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4485 name = _("<unknown>");
4486 else if (name[0] == 0)
4487 name = bfd_section_name (input_bfd, sec);
4489 (*_bfd_error_handler)
4490 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4499 case R_ALPHA_REFLONG:
4500 case R_ALPHA_REFQUAD:
4501 case R_ALPHA_DTPREL64:
4502 case R_ALPHA_TPREL64:
4504 long dynindx, dyntype = r_type;
4507 /* Careful here to remember RELATIVE relocations for global
4508 variables for symbolic shared objects. */
4510 if (dynamic_symbol_p)
4512 BFD_ASSERT(h->root.dynindx != -1);
4513 dynindx = h->root.dynindx;
4515 addend = 0, value = 0;
4517 else if (r_type == R_ALPHA_DTPREL64)
4519 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4523 else if (r_type == R_ALPHA_TPREL64)
4525 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4526 if (!info->shared || info->pie)
4532 dynaddend = value - dtp_base;
4534 else if (info->shared
4535 && r_symndx != STN_UNDEF
4536 && (input_section->flags & SEC_ALLOC)
4538 && !(unresolved_reloc
4539 && (_bfd_elf_section_offset (output_bfd, info,
4544 if (r_type == R_ALPHA_REFLONG)
4546 (*_bfd_error_handler)
4547 (_("%B: unhandled dynamic relocation against %s"),
4549 h->root.root.root.string);
4553 dyntype = R_ALPHA_RELATIVE;
4559 if (input_section->flags & SEC_ALLOC)
4560 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4561 srel, rel->r_offset, dynindx,
4562 dyntype, dynaddend);
4566 case R_ALPHA_SREL16:
4567 case R_ALPHA_SREL32:
4568 case R_ALPHA_SREL64:
4569 if (dynamic_symbol_p)
4571 (*_bfd_error_handler)
4572 (_("%B: pc-relative relocation against dynamic symbol %s"),
4573 input_bfd, h->root.root.root.string);
4576 else if ((info->shared || info->pie) && undef_weak_ref)
4578 (*_bfd_error_handler)
4579 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4580 input_bfd, h->root.root.root.string);
4585 /* ??? .eh_frame references to discarded sections will be smashed
4586 to relocations against SHN_UNDEF. The .eh_frame format allows
4587 NULL to be encoded as 0 in any format, so this works here. */
4588 if (r_symndx == STN_UNDEF
4589 || (unresolved_reloc
4590 && _bfd_elf_section_offset (output_bfd, info,
4592 rel->r_offset) == (bfd_vma) -1))
4593 howto = (elf64_alpha_howto_table
4594 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4597 case R_ALPHA_TLSLDM:
4598 /* Ignore the symbol for the relocation. The result is always
4599 the current module. */
4600 dynamic_symbol_p = 0;
4604 if (!gotent->reloc_done)
4606 gotent->reloc_done = 1;
4608 /* Note that the module index for the main program is 1. */
4609 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4610 sgot->contents + gotent->got_offset);
4612 /* If the symbol has been forced local, output a
4613 DTPMOD64 reloc, otherwise it will be handled in
4614 finish_dynamic_symbol. */
4615 if (info->shared && !dynamic_symbol_p)
4616 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4617 gotent->got_offset, 0,
4618 R_ALPHA_DTPMOD64, 0);
4620 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4624 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4627 bfd_put_64 (output_bfd, value,
4628 sgot->contents + gotent->got_offset + 8);
4631 value = (sgot->output_section->vma
4632 + sgot->output_offset
4633 + gotent->got_offset);
4637 case R_ALPHA_DTPRELHI:
4638 case R_ALPHA_DTPRELLO:
4639 case R_ALPHA_DTPREL16:
4640 if (dynamic_symbol_p)
4642 (*_bfd_error_handler)
4643 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4644 input_bfd, h->root.root.root.string);
4647 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4649 if (r_type == R_ALPHA_DTPRELHI)
4650 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4653 case R_ALPHA_TPRELHI:
4654 case R_ALPHA_TPRELLO:
4655 case R_ALPHA_TPREL16:
4656 if (info->shared && !info->pie)
4658 (*_bfd_error_handler)
4659 (_("%B: TLS local exec code cannot be linked into shared objects"),
4663 else if (dynamic_symbol_p)
4665 (*_bfd_error_handler)
4666 (_("%B: tp-relative relocation against dynamic symbol %s"),
4667 input_bfd, h->root.root.root.string);
4670 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4672 if (r_type == R_ALPHA_TPRELHI)
4673 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4676 case R_ALPHA_GOTDTPREL:
4677 case R_ALPHA_GOTTPREL:
4678 BFD_ASSERT(sgot != NULL);
4679 BFD_ASSERT(gp != 0);
4680 BFD_ASSERT(gotent != NULL);
4681 BFD_ASSERT(gotent->use_count >= 1);
4683 if (!gotent->reloc_done)
4685 gotent->reloc_done = 1;
4687 if (dynamic_symbol_p)
4691 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4692 if (r_type == R_ALPHA_GOTDTPREL)
4694 else if (!info->shared)
4698 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4699 gotent->got_offset, 0,
4705 bfd_put_64 (output_bfd, value,
4706 sgot->contents + gotent->got_offset);
4709 value = (sgot->output_section->vma
4710 + sgot->output_offset
4711 + gotent->got_offset);
4717 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4718 contents, rel->r_offset, value, 0);
4727 case bfd_reloc_overflow:
4731 /* Don't warn if the overflow is due to pc relative reloc
4732 against discarded section. Section optimization code should
4735 if (r_symndx < symtab_hdr->sh_info
4736 && sec != NULL && howto->pc_relative
4737 && discarded_section (sec))
4744 name = (bfd_elf_string_from_elf_section
4745 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4749 name = bfd_section_name (input_bfd, sec);
4751 if (! ((*info->callbacks->reloc_overflow)
4752 (info, (h ? &h->root.root : NULL), name, howto->name,
4753 (bfd_vma) 0, input_bfd, input_section,
4760 case bfd_reloc_outofrange:
4768 /* Finish up dynamic symbol handling. We set the contents of various
4769 dynamic sections here. */
4772 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4773 struct elf_link_hash_entry *h,
4774 Elf_Internal_Sym *sym)
4776 struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4777 bfd *dynobj = elf_hash_table(info)->dynobj;
4781 /* Fill in the .plt entry for this symbol. */
4782 asection *splt, *sgot, *srel;
4783 Elf_Internal_Rela outrel;
4785 bfd_vma got_addr, plt_addr;
4787 struct alpha_elf_got_entry *gotent;
4789 BFD_ASSERT (h->dynindx != -1);
4791 splt = bfd_get_linker_section (dynobj, ".plt");
4792 BFD_ASSERT (splt != NULL);
4793 srel = bfd_get_linker_section (dynobj, ".rela.plt");
4794 BFD_ASSERT (srel != NULL);
4796 for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4797 if (gotent->reloc_type == R_ALPHA_LITERAL
4798 && gotent->use_count > 0)
4803 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4804 BFD_ASSERT (sgot != NULL);
4806 BFD_ASSERT (gotent->got_offset != -1);
4807 BFD_ASSERT (gotent->plt_offset != -1);
4809 got_addr = (sgot->output_section->vma
4810 + sgot->output_offset
4811 + gotent->got_offset);
4812 plt_addr = (splt->output_section->vma
4813 + splt->output_offset
4814 + gotent->plt_offset);
4816 plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4818 /* Fill in the entry in the procedure linkage table. */
4819 if (elf64_alpha_use_secureplt)
4821 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4822 insn = INSN_AD (INSN_BR, 31, disp);
4823 bfd_put_32 (output_bfd, insn,
4824 splt->contents + gotent->plt_offset);
4826 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4827 / NEW_PLT_ENTRY_SIZE);
4831 disp = -(gotent->plt_offset + 4);
4832 insn = INSN_AD (INSN_BR, 28, disp);
4833 bfd_put_32 (output_bfd, insn,
4834 splt->contents + gotent->plt_offset);
4835 bfd_put_32 (output_bfd, INSN_UNOP,
4836 splt->contents + gotent->plt_offset + 4);
4837 bfd_put_32 (output_bfd, INSN_UNOP,
4838 splt->contents + gotent->plt_offset + 8);
4840 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4841 / OLD_PLT_ENTRY_SIZE);
4844 /* Fill in the entry in the .rela.plt section. */
4845 outrel.r_offset = got_addr;
4846 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4847 outrel.r_addend = 0;
4849 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4850 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4852 /* Fill in the entry in the .got. */
4853 bfd_put_64 (output_bfd, plt_addr,
4854 sgot->contents + gotent->got_offset);
4857 else if (alpha_elf_dynamic_symbol_p (h, info))
4859 /* Fill in the dynamic relocations for this symbol's .got entries. */
4861 struct alpha_elf_got_entry *gotent;
4863 srel = bfd_get_linker_section (dynobj, ".rela.got");
4864 BFD_ASSERT (srel != NULL);
4866 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4868 gotent = gotent->next)
4873 if (gotent->use_count == 0)
4876 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4878 r_type = gotent->reloc_type;
4881 case R_ALPHA_LITERAL:
4882 r_type = R_ALPHA_GLOB_DAT;
4885 r_type = R_ALPHA_DTPMOD64;
4887 case R_ALPHA_GOTDTPREL:
4888 r_type = R_ALPHA_DTPREL64;
4890 case R_ALPHA_GOTTPREL:
4891 r_type = R_ALPHA_TPREL64;
4893 case R_ALPHA_TLSLDM:
4898 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4899 gotent->got_offset, h->dynindx,
4900 r_type, gotent->addend);
4902 if (gotent->reloc_type == R_ALPHA_TLSGD)
4903 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4904 gotent->got_offset + 8, h->dynindx,
4905 R_ALPHA_DTPREL64, gotent->addend);
4909 /* Mark some specially defined symbols as absolute. */
4910 if (h == elf_hash_table (info)->hdynamic
4911 || h == elf_hash_table (info)->hgot
4912 || h == elf_hash_table (info)->hplt)
4913 sym->st_shndx = SHN_ABS;
4918 /* Finish up the dynamic sections. */
4921 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
4922 struct bfd_link_info *info)
4927 dynobj = elf_hash_table (info)->dynobj;
4928 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4930 if (elf_hash_table (info)->dynamic_sections_created)
4932 asection *splt, *sgotplt, *srelaplt;
4933 Elf64_External_Dyn *dyncon, *dynconend;
4934 bfd_vma plt_vma, gotplt_vma;
4936 splt = bfd_get_linker_section (dynobj, ".plt");
4937 srelaplt = bfd_get_linker_section (output_bfd, ".rela.plt");
4938 BFD_ASSERT (splt != NULL && sdyn != NULL);
4940 plt_vma = splt->output_section->vma + splt->output_offset;
4943 if (elf64_alpha_use_secureplt)
4945 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
4946 BFD_ASSERT (sgotplt != NULL);
4947 if (sgotplt->size > 0)
4948 gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
4951 dyncon = (Elf64_External_Dyn *) sdyn->contents;
4952 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4953 for (; dyncon < dynconend; dyncon++)
4955 Elf_Internal_Dyn dyn;
4957 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4963 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
4966 dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
4969 dyn.d_un.d_ptr = srelaplt ? srelaplt->vma : 0;
4973 /* My interpretation of the TIS v1.1 ELF document indicates
4974 that RELASZ should not include JMPREL. This is not what
4975 the rest of the BFD does. It is, however, what the
4976 glibc ld.so wants. Do this fixup here until we found
4977 out who is right. */
4979 dyn.d_un.d_val -= srelaplt->size;
4983 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
4986 /* Initialize the plt header. */
4992 if (elf64_alpha_use_secureplt)
4994 ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
4996 insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
4997 bfd_put_32 (output_bfd, insn, splt->contents);
4999 insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
5000 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5002 insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
5003 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5005 insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5006 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5008 insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5009 bfd_put_32 (output_bfd, insn, splt->contents + 16);
5011 insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5012 bfd_put_32 (output_bfd, insn, splt->contents + 20);
5014 insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5015 bfd_put_32 (output_bfd, insn, splt->contents + 24);
5017 insn = INSN_AB (INSN_JMP, 31, 27);
5018 bfd_put_32 (output_bfd, insn, splt->contents + 28);
5020 insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5021 bfd_put_32 (output_bfd, insn, splt->contents + 32);
5025 insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */
5026 bfd_put_32 (output_bfd, insn, splt->contents);
5028 insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5029 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5032 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5034 insn = INSN_AB (INSN_JMP, 27, 27);
5035 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5037 /* The next two words will be filled in by ld.so. */
5038 bfd_put_64 (output_bfd, 0, splt->contents + 16);
5039 bfd_put_64 (output_bfd, 0, splt->contents + 24);
5042 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5049 /* We need to use a special link routine to handle the .mdebug section.
5050 We need to merge all instances of these sections together, not write
5051 them all out sequentially. */
5054 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5057 struct bfd_link_order *p;
5058 asection *mdebug_sec;
5059 struct ecoff_debug_info debug;
5060 const struct ecoff_debug_swap *swap
5061 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5062 HDRR *symhdr = &debug.symbolic_header;
5063 void * mdebug_handle = NULL;
5064 struct alpha_elf_link_hash_table * htab;
5066 htab = alpha_elf_hash_table (info);
5070 /* Go through the sections and collect the mdebug information. */
5072 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5074 if (strcmp (o->name, ".mdebug") == 0)
5076 struct extsym_info einfo;
5078 /* We have found the .mdebug section in the output file.
5079 Look through all the link_orders comprising it and merge
5080 the information together. */
5081 symhdr->magic = swap->sym_magic;
5082 /* FIXME: What should the version stamp be? */
5084 symhdr->ilineMax = 0;
5088 symhdr->isymMax = 0;
5089 symhdr->ioptMax = 0;
5090 symhdr->iauxMax = 0;
5092 symhdr->issExtMax = 0;
5095 symhdr->iextMax = 0;
5097 /* We accumulate the debugging information itself in the
5098 debug_info structure. */
5100 debug.external_dnr = NULL;
5101 debug.external_pdr = NULL;
5102 debug.external_sym = NULL;
5103 debug.external_opt = NULL;
5104 debug.external_aux = NULL;
5106 debug.ssext = debug.ssext_end = NULL;
5107 debug.external_fdr = NULL;
5108 debug.external_rfd = NULL;
5109 debug.external_ext = debug.external_ext_end = NULL;
5111 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5112 if (mdebug_handle == NULL)
5121 static const char * const name[] =
5123 ".text", ".init", ".fini", ".data",
5124 ".rodata", ".sdata", ".sbss", ".bss"
5126 static const int sc[] = { scText, scInit, scFini, scData,
5127 scRData, scSData, scSBss, scBss };
5130 esym.cobol_main = 0;
5134 esym.asym.iss = issNil;
5135 esym.asym.st = stLocal;
5136 esym.asym.reserved = 0;
5137 esym.asym.index = indexNil;
5138 for (i = 0; i < 8; i++)
5140 esym.asym.sc = sc[i];
5141 s = bfd_get_section_by_name (abfd, name[i]);
5144 esym.asym.value = s->vma;
5145 last = s->vma + s->size;
5148 esym.asym.value = last;
5150 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5156 for (p = o->map_head.link_order;
5157 p != (struct bfd_link_order *) NULL;
5160 asection *input_section;
5162 const struct ecoff_debug_swap *input_swap;
5163 struct ecoff_debug_info input_debug;
5167 if (p->type != bfd_indirect_link_order)
5169 if (p->type == bfd_data_link_order)
5174 input_section = p->u.indirect.section;
5175 input_bfd = input_section->owner;
5177 if (! is_alpha_elf (input_bfd))
5178 /* I don't know what a non ALPHA ELF bfd would be
5179 doing with a .mdebug section, but I don't really
5180 want to deal with it. */
5183 input_swap = (get_elf_backend_data (input_bfd)
5184 ->elf_backend_ecoff_debug_swap);
5186 BFD_ASSERT (p->size == input_section->size);
5188 /* The ECOFF linking code expects that we have already
5189 read in the debugging information and set up an
5190 ecoff_debug_info structure, so we do that now. */
5191 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5195 if (! (bfd_ecoff_debug_accumulate
5196 (mdebug_handle, abfd, &debug, swap, input_bfd,
5197 &input_debug, input_swap, info)))
5200 /* Loop through the external symbols. For each one with
5201 interesting information, try to find the symbol in
5202 the linker global hash table and save the information
5203 for the output external symbols. */
5204 eraw_src = (char *) input_debug.external_ext;
5205 eraw_end = (eraw_src
5206 + (input_debug.symbolic_header.iextMax
5207 * input_swap->external_ext_size));
5209 eraw_src < eraw_end;
5210 eraw_src += input_swap->external_ext_size)
5214 struct alpha_elf_link_hash_entry *h;
5216 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5217 if (ext.asym.sc == scNil
5218 || ext.asym.sc == scUndefined
5219 || ext.asym.sc == scSUndefined)
5222 name = input_debug.ssext + ext.asym.iss;
5223 h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5224 if (h == NULL || h->esym.ifd != -2)
5230 < input_debug.symbolic_header.ifdMax);
5231 ext.ifd = input_debug.ifdmap[ext.ifd];
5237 /* Free up the information we just read. */
5238 free (input_debug.line);
5239 free (input_debug.external_dnr);
5240 free (input_debug.external_pdr);
5241 free (input_debug.external_sym);
5242 free (input_debug.external_opt);
5243 free (input_debug.external_aux);
5244 free (input_debug.ss);
5245 free (input_debug.ssext);
5246 free (input_debug.external_fdr);
5247 free (input_debug.external_rfd);
5248 free (input_debug.external_ext);
5250 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5251 elf_link_input_bfd ignores this section. */
5252 input_section->flags &=~ SEC_HAS_CONTENTS;
5255 /* Build the external symbol information. */
5258 einfo.debug = &debug;
5260 einfo.failed = FALSE;
5261 elf_link_hash_traverse (elf_hash_table (info),
5262 elf64_alpha_output_extsym,
5267 /* Set the size of the .mdebug section. */
5268 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5270 /* Skip this section later on (I don't think this currently
5271 matters, but someday it might). */
5272 o->map_head.link_order = (struct bfd_link_order *) NULL;
5278 /* Invoke the regular ELF backend linker to do all the work. */
5279 if (! bfd_elf_final_link (abfd, info))
5282 /* Now write out the computed sections. */
5284 /* The .got subsections... */
5286 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5287 for (i = htab->got_list;
5289 i = alpha_elf_tdata(i)->got_link_next)
5293 /* elf_bfd_final_link already did everything in dynobj. */
5297 sgot = alpha_elf_tdata(i)->got;
5298 if (! bfd_set_section_contents (abfd, sgot->output_section,
5300 (file_ptr) sgot->output_offset,
5306 if (mdebug_sec != (asection *) NULL)
5308 BFD_ASSERT (abfd->output_has_begun);
5309 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5311 mdebug_sec->filepos))
5314 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5320 static enum elf_reloc_type_class
5321 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5322 const asection *rel_sec ATTRIBUTE_UNUSED,
5323 const Elf_Internal_Rela *rela)
5325 switch ((int) ELF64_R_TYPE (rela->r_info))
5327 case R_ALPHA_RELATIVE:
5328 return reloc_class_relative;
5329 case R_ALPHA_JMP_SLOT:
5330 return reloc_class_plt;
5332 return reloc_class_copy;
5334 return reloc_class_normal;
5338 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5340 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5341 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5342 { NULL, 0, 0, 0, 0 }
5345 /* ECOFF swapping routines. These are used when dealing with the
5346 .mdebug section, which is in the ECOFF debugging format. Copied
5347 from elf32-mips.c. */
5348 static const struct ecoff_debug_swap
5349 elf64_alpha_ecoff_debug_swap =
5351 /* Symbol table magic number. */
5353 /* Alignment of debugging information. E.g., 4. */
5355 /* Sizes of external symbolic information. */
5356 sizeof (struct hdr_ext),
5357 sizeof (struct dnr_ext),
5358 sizeof (struct pdr_ext),
5359 sizeof (struct sym_ext),
5360 sizeof (struct opt_ext),
5361 sizeof (struct fdr_ext),
5362 sizeof (struct rfd_ext),
5363 sizeof (struct ext_ext),
5364 /* Functions to swap in external symbolic data. */
5373 _bfd_ecoff_swap_tir_in,
5374 _bfd_ecoff_swap_rndx_in,
5375 /* Functions to swap out external symbolic data. */
5384 _bfd_ecoff_swap_tir_out,
5385 _bfd_ecoff_swap_rndx_out,
5386 /* Function to read in symbolic data. */
5387 elf64_alpha_read_ecoff_info
5390 /* Use a non-standard hash bucket size of 8. */
5392 static const struct elf_size_info alpha_elf_size_info =
5394 sizeof (Elf64_External_Ehdr),
5395 sizeof (Elf64_External_Phdr),
5396 sizeof (Elf64_External_Shdr),
5397 sizeof (Elf64_External_Rel),
5398 sizeof (Elf64_External_Rela),
5399 sizeof (Elf64_External_Sym),
5400 sizeof (Elf64_External_Dyn),
5401 sizeof (Elf_External_Note),
5405 ELFCLASS64, EV_CURRENT,
5406 bfd_elf64_write_out_phdrs,
5407 bfd_elf64_write_shdrs_and_ehdr,
5408 bfd_elf64_checksum_contents,
5409 bfd_elf64_write_relocs,
5410 bfd_elf64_swap_symbol_in,
5411 bfd_elf64_swap_symbol_out,
5412 bfd_elf64_slurp_reloc_table,
5413 bfd_elf64_slurp_symbol_table,
5414 bfd_elf64_swap_dyn_in,
5415 bfd_elf64_swap_dyn_out,
5416 bfd_elf64_swap_reloc_in,
5417 bfd_elf64_swap_reloc_out,
5418 bfd_elf64_swap_reloca_in,
5419 bfd_elf64_swap_reloca_out
5422 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5423 #define TARGET_LITTLE_NAME "elf64-alpha"
5424 #define ELF_ARCH bfd_arch_alpha
5425 #define ELF_TARGET_ID ALPHA_ELF_DATA
5426 #define ELF_MACHINE_CODE EM_ALPHA
5427 #define ELF_MAXPAGESIZE 0x10000
5428 #define ELF_COMMONPAGESIZE 0x2000
5430 #define bfd_elf64_bfd_link_hash_table_create \
5431 elf64_alpha_bfd_link_hash_table_create
5433 #define bfd_elf64_bfd_reloc_type_lookup \
5434 elf64_alpha_bfd_reloc_type_lookup
5435 #define bfd_elf64_bfd_reloc_name_lookup \
5436 elf64_alpha_bfd_reloc_name_lookup
5437 #define elf_info_to_howto \
5438 elf64_alpha_info_to_howto
5440 #define bfd_elf64_mkobject \
5441 elf64_alpha_mkobject
5442 #define elf_backend_object_p \
5443 elf64_alpha_object_p
5445 #define elf_backend_section_from_shdr \
5446 elf64_alpha_section_from_shdr
5447 #define elf_backend_section_flags \
5448 elf64_alpha_section_flags
5449 #define elf_backend_fake_sections \
5450 elf64_alpha_fake_sections
5452 #define bfd_elf64_bfd_is_local_label_name \
5453 elf64_alpha_is_local_label_name
5454 #define bfd_elf64_find_nearest_line \
5455 elf64_alpha_find_nearest_line
5456 #define bfd_elf64_bfd_relax_section \
5457 elf64_alpha_relax_section
5459 #define elf_backend_add_symbol_hook \
5460 elf64_alpha_add_symbol_hook
5461 #define elf_backend_relocs_compatible \
5462 _bfd_elf_relocs_compatible
5463 #define elf_backend_check_relocs \
5464 elf64_alpha_check_relocs
5465 #define elf_backend_create_dynamic_sections \
5466 elf64_alpha_create_dynamic_sections
5467 #define elf_backend_adjust_dynamic_symbol \
5468 elf64_alpha_adjust_dynamic_symbol
5469 #define elf_backend_merge_symbol_attribute \
5470 elf64_alpha_merge_symbol_attribute
5471 #define elf_backend_copy_indirect_symbol \
5472 elf64_alpha_copy_indirect_symbol
5473 #define elf_backend_always_size_sections \
5474 elf64_alpha_always_size_sections
5475 #define elf_backend_size_dynamic_sections \
5476 elf64_alpha_size_dynamic_sections
5477 #define elf_backend_omit_section_dynsym \
5478 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5479 #define elf_backend_relocate_section \
5480 elf64_alpha_relocate_section
5481 #define elf_backend_finish_dynamic_symbol \
5482 elf64_alpha_finish_dynamic_symbol
5483 #define elf_backend_finish_dynamic_sections \
5484 elf64_alpha_finish_dynamic_sections
5485 #define bfd_elf64_bfd_final_link \
5486 elf64_alpha_final_link
5487 #define elf_backend_reloc_type_class \
5488 elf64_alpha_reloc_type_class
5490 #define elf_backend_can_gc_sections 1
5491 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5492 #define elf_backend_gc_sweep_hook elf64_alpha_gc_sweep_hook
5494 #define elf_backend_ecoff_debug_swap \
5495 &elf64_alpha_ecoff_debug_swap
5497 #define elf_backend_size_info \
5500 #define elf_backend_special_sections \
5501 elf64_alpha_special_sections
5503 /* A few constants that determine how the .plt section is set up. */
5504 #define elf_backend_want_got_plt 0
5505 #define elf_backend_plt_readonly 0
5506 #define elf_backend_want_plt_sym 1
5507 #define elf_backend_got_header_size 0
5509 #include "elf64-target.h"
5511 /* FreeBSD support. */
5513 #undef TARGET_LITTLE_SYM
5514 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5515 #undef TARGET_LITTLE_NAME
5516 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5518 #define ELF_OSABI ELFOSABI_FREEBSD
5520 /* The kernel recognizes executables as valid only if they carry a
5521 "FreeBSD" label in the ELF header. So we put this label on all
5522 executables and (for simplicity) also all other object files. */
5525 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5526 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5528 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5530 i_ehdrp = elf_elfheader (abfd);
5532 /* Put an ABI label supported by FreeBSD >= 4.1. */
5533 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5534 #ifdef OLD_FREEBSD_ABI_LABEL
5535 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5536 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5540 #undef elf_backend_post_process_headers
5541 #define elf_backend_post_process_headers \
5542 elf64_alpha_fbsd_post_process_headers
5545 #define elf64_bed elf64_alpha_fbsd_bed
5547 #include "elf64-target.h"