1 /* Alpha specific support for 64-bit ELF
2 Copyright (C) 1996-2016 Free Software Foundation, Inc.
3 Contributed by Richard Henderson <rth@tamu.edu>.
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 3, /* 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);
1109 if (r_type >= R_ALPHA_max)
1111 /* xgettext:c-format */
1112 _bfd_error_handler (_("%B: unrecognised Alpha reloc number: %d"),
1114 bfd_set_error (bfd_error_bad_value);
1115 r_type = R_ALPHA_NONE;
1117 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1120 /* These two relocations create a two-word entry in the got. */
1121 #define alpha_got_entry_size(r_type) \
1122 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1124 /* This is PT_TLS segment p_vaddr. */
1125 #define alpha_get_dtprel_base(info) \
1126 (elf_hash_table (info)->tls_sec->vma)
1128 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1129 is assigned offset round(16, PT_TLS p_align). */
1130 #define alpha_get_tprel_base(info) \
1131 (elf_hash_table (info)->tls_sec->vma \
1132 - align_power ((bfd_vma) 16, \
1133 elf_hash_table (info)->tls_sec->alignment_power))
1135 /* Handle an Alpha specific section when reading an object file. This
1136 is called when bfd_section_from_shdr finds a section with an unknown
1138 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1142 elf64_alpha_section_from_shdr (bfd *abfd,
1143 Elf_Internal_Shdr *hdr,
1149 /* There ought to be a place to keep ELF backend specific flags, but
1150 at the moment there isn't one. We just keep track of the
1151 sections by their name, instead. Fortunately, the ABI gives
1152 suggested names for all the MIPS specific sections, so we will
1153 probably get away with this. */
1154 switch (hdr->sh_type)
1156 case SHT_ALPHA_DEBUG:
1157 if (strcmp (name, ".mdebug") != 0)
1164 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1166 newsect = hdr->bfd_section;
1168 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1170 if (! bfd_set_section_flags (abfd, newsect,
1171 (bfd_get_section_flags (abfd, newsect)
1179 /* Convert Alpha specific section flags to bfd internal section flags. */
1182 elf64_alpha_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
1184 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1185 *flags |= SEC_SMALL_DATA;
1190 /* Set the correct type for an Alpha ELF section. We do this by the
1191 section name, which is a hack, but ought to work. */
1194 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1196 register const char *name;
1198 name = bfd_get_section_name (abfd, sec);
1200 if (strcmp (name, ".mdebug") == 0)
1202 hdr->sh_type = SHT_ALPHA_DEBUG;
1203 /* In a shared object on Irix 5.3, the .mdebug section has an
1204 entsize of 0. FIXME: Does this matter? */
1205 if ((abfd->flags & DYNAMIC) != 0 )
1206 hdr->sh_entsize = 0;
1208 hdr->sh_entsize = 1;
1210 else if ((sec->flags & SEC_SMALL_DATA)
1211 || strcmp (name, ".sdata") == 0
1212 || strcmp (name, ".sbss") == 0
1213 || strcmp (name, ".lit4") == 0
1214 || strcmp (name, ".lit8") == 0)
1215 hdr->sh_flags |= SHF_ALPHA_GPREL;
1220 /* Hook called by the linker routine which adds symbols from an object
1221 file. We use it to put .comm items in .sbss, and not .bss. */
1224 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1225 Elf_Internal_Sym *sym,
1226 const char **namep ATTRIBUTE_UNUSED,
1227 flagword *flagsp ATTRIBUTE_UNUSED,
1228 asection **secp, bfd_vma *valp)
1230 if (sym->st_shndx == SHN_COMMON
1231 && !bfd_link_relocatable (info)
1232 && sym->st_size <= elf_gp_size (abfd))
1234 /* Common symbols less than or equal to -G nn bytes are
1235 automatically put into .sbss. */
1237 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1241 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1244 | SEC_LINKER_CREATED));
1250 *valp = sym->st_size;
1256 /* Create the .got section. */
1259 elf64_alpha_create_got_section (bfd *abfd,
1260 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1265 if (! is_alpha_elf (abfd))
1268 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1269 | SEC_LINKER_CREATED);
1270 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1272 || !bfd_set_section_alignment (abfd, s, 3))
1275 alpha_elf_tdata (abfd)->got = s;
1277 /* Make sure the object's gotobj is set to itself so that we default
1278 to every object with its own .got. We'll merge .gots later once
1279 we've collected each object's info. */
1280 alpha_elf_tdata (abfd)->gotobj = abfd;
1285 /* Create all the dynamic sections. */
1288 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1292 struct elf_link_hash_entry *h;
1294 if (! is_alpha_elf (abfd))
1297 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1299 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1300 | SEC_LINKER_CREATED
1301 | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1302 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1303 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4))
1306 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1308 h = _bfd_elf_define_linkage_sym (abfd, info, s,
1309 "_PROCEDURE_LINKAGE_TABLE_");
1310 elf_hash_table (info)->hplt = h;
1314 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1315 | SEC_LINKER_CREATED | SEC_READONLY);
1316 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1317 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1320 if (elf64_alpha_use_secureplt)
1322 flags = SEC_ALLOC | SEC_LINKER_CREATED;
1323 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1324 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1328 /* We may or may not have created a .got section for this object, but
1329 we definitely havn't done the rest of the work. */
1331 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1333 if (!elf64_alpha_create_got_section (abfd, info))
1337 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1338 | SEC_LINKER_CREATED | SEC_READONLY);
1339 s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1341 || !bfd_set_section_alignment (abfd, s, 3))
1344 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1345 dynobj's .got section. We don't do this in the linker script
1346 because we don't want to define the symbol if we are not creating
1347 a global offset table. */
1348 h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1349 "_GLOBAL_OFFSET_TABLE_");
1350 elf_hash_table (info)->hgot = h;
1357 /* Read ECOFF debugging information from a .mdebug section into a
1358 ecoff_debug_info structure. */
1361 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1362 struct ecoff_debug_info *debug)
1365 const struct ecoff_debug_swap *swap;
1366 char *ext_hdr = NULL;
1368 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1369 memset (debug, 0, sizeof (*debug));
1371 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1372 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1375 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1376 swap->external_hdr_size))
1379 symhdr = &debug->symbolic_header;
1380 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1382 /* The symbolic header contains absolute file offsets and sizes to
1384 #define READ(ptr, offset, count, size, type) \
1385 if (symhdr->count == 0) \
1386 debug->ptr = NULL; \
1389 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1390 debug->ptr = (type) bfd_malloc (amt); \
1391 if (debug->ptr == NULL) \
1392 goto error_return; \
1393 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1394 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1395 goto error_return; \
1398 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1399 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1400 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1401 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1402 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1403 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1405 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1406 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1407 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1408 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1409 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1417 if (ext_hdr != NULL)
1419 if (debug->line != NULL)
1421 if (debug->external_dnr != NULL)
1422 free (debug->external_dnr);
1423 if (debug->external_pdr != NULL)
1424 free (debug->external_pdr);
1425 if (debug->external_sym != NULL)
1426 free (debug->external_sym);
1427 if (debug->external_opt != NULL)
1428 free (debug->external_opt);
1429 if (debug->external_aux != NULL)
1430 free (debug->external_aux);
1431 if (debug->ss != NULL)
1433 if (debug->ssext != NULL)
1434 free (debug->ssext);
1435 if (debug->external_fdr != NULL)
1436 free (debug->external_fdr);
1437 if (debug->external_rfd != NULL)
1438 free (debug->external_rfd);
1439 if (debug->external_ext != NULL)
1440 free (debug->external_ext);
1444 /* Alpha ELF local labels start with '$'. */
1447 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1449 return name[0] == '$';
1453 elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
1454 asection *section, bfd_vma offset,
1455 const char **filename_ptr,
1456 const char **functionname_ptr,
1457 unsigned int *line_ptr,
1458 unsigned int *discriminator_ptr)
1462 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
1463 filename_ptr, functionname_ptr,
1464 line_ptr, discriminator_ptr,
1465 dwarf_debug_sections, 0,
1466 &elf_tdata (abfd)->dwarf2_find_line_info))
1469 msec = bfd_get_section_by_name (abfd, ".mdebug");
1473 struct alpha_elf_find_line *fi;
1474 const struct ecoff_debug_swap * const swap =
1475 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1477 /* If we are called during a link, alpha_elf_final_link may have
1478 cleared the SEC_HAS_CONTENTS field. We force it back on here
1479 if appropriate (which it normally will be). */
1480 origflags = msec->flags;
1481 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1482 msec->flags |= SEC_HAS_CONTENTS;
1484 fi = alpha_elf_tdata (abfd)->find_line_info;
1487 bfd_size_type external_fdr_size;
1490 struct fdr *fdr_ptr;
1491 bfd_size_type amt = sizeof (struct alpha_elf_find_line);
1493 fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt);
1496 msec->flags = origflags;
1500 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1502 msec->flags = origflags;
1506 /* Swap in the FDR information. */
1507 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1508 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1509 if (fi->d.fdr == NULL)
1511 msec->flags = origflags;
1514 external_fdr_size = swap->external_fdr_size;
1515 fdr_ptr = fi->d.fdr;
1516 fraw_src = (char *) fi->d.external_fdr;
1517 fraw_end = (fraw_src
1518 + fi->d.symbolic_header.ifdMax * external_fdr_size);
1519 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1520 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
1522 alpha_elf_tdata (abfd)->find_line_info = fi;
1524 /* Note that we don't bother to ever free this information.
1525 find_nearest_line is either called all the time, as in
1526 objdump -l, so the information should be saved, or it is
1527 rarely called, as in ld error messages, so the memory
1528 wasted is unimportant. Still, it would probably be a
1529 good idea for free_cached_info to throw it away. */
1532 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1533 &fi->i, filename_ptr, functionname_ptr,
1536 msec->flags = origflags;
1540 msec->flags = origflags;
1543 /* Fall back on the generic ELF find_nearest_line routine. */
1545 return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
1546 filename_ptr, functionname_ptr,
1547 line_ptr, discriminator_ptr);
1550 /* Structure used to pass information to alpha_elf_output_extsym. */
1555 struct bfd_link_info *info;
1556 struct ecoff_debug_info *debug;
1557 const struct ecoff_debug_swap *swap;
1562 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
1564 struct extsym_info *einfo = (struct extsym_info *) data;
1566 asection *sec, *output_section;
1568 if (h->root.indx == -2)
1570 else if ((h->root.def_dynamic
1571 || h->root.ref_dynamic
1572 || h->root.root.type == bfd_link_hash_new)
1573 && !h->root.def_regular
1574 && !h->root.ref_regular)
1576 else if (einfo->info->strip == strip_all
1577 || (einfo->info->strip == strip_some
1578 && bfd_hash_lookup (einfo->info->keep_hash,
1579 h->root.root.root.string,
1580 FALSE, FALSE) == NULL))
1588 if (h->esym.ifd == -2)
1591 h->esym.cobol_main = 0;
1592 h->esym.weakext = 0;
1593 h->esym.reserved = 0;
1594 h->esym.ifd = ifdNil;
1595 h->esym.asym.value = 0;
1596 h->esym.asym.st = stGlobal;
1598 if (h->root.root.type != bfd_link_hash_defined
1599 && h->root.root.type != bfd_link_hash_defweak)
1600 h->esym.asym.sc = scAbs;
1605 sec = h->root.root.u.def.section;
1606 output_section = sec->output_section;
1608 /* When making a shared library and symbol h is the one from
1609 the another shared library, OUTPUT_SECTION may be null. */
1610 if (output_section == NULL)
1611 h->esym.asym.sc = scUndefined;
1614 name = bfd_section_name (output_section->owner, output_section);
1616 if (strcmp (name, ".text") == 0)
1617 h->esym.asym.sc = scText;
1618 else if (strcmp (name, ".data") == 0)
1619 h->esym.asym.sc = scData;
1620 else if (strcmp (name, ".sdata") == 0)
1621 h->esym.asym.sc = scSData;
1622 else if (strcmp (name, ".rodata") == 0
1623 || strcmp (name, ".rdata") == 0)
1624 h->esym.asym.sc = scRData;
1625 else if (strcmp (name, ".bss") == 0)
1626 h->esym.asym.sc = scBss;
1627 else if (strcmp (name, ".sbss") == 0)
1628 h->esym.asym.sc = scSBss;
1629 else if (strcmp (name, ".init") == 0)
1630 h->esym.asym.sc = scInit;
1631 else if (strcmp (name, ".fini") == 0)
1632 h->esym.asym.sc = scFini;
1634 h->esym.asym.sc = scAbs;
1638 h->esym.asym.reserved = 0;
1639 h->esym.asym.index = indexNil;
1642 if (h->root.root.type == bfd_link_hash_common)
1643 h->esym.asym.value = h->root.root.u.c.size;
1644 else if (h->root.root.type == bfd_link_hash_defined
1645 || h->root.root.type == bfd_link_hash_defweak)
1647 if (h->esym.asym.sc == scCommon)
1648 h->esym.asym.sc = scBss;
1649 else if (h->esym.asym.sc == scSCommon)
1650 h->esym.asym.sc = scSBss;
1652 sec = h->root.root.u.def.section;
1653 output_section = sec->output_section;
1654 if (output_section != NULL)
1655 h->esym.asym.value = (h->root.root.u.def.value
1656 + sec->output_offset
1657 + output_section->vma);
1659 h->esym.asym.value = 0;
1662 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1663 h->root.root.root.string,
1666 einfo->failed = TRUE;
1673 /* Search for and possibly create a got entry. */
1675 static struct alpha_elf_got_entry *
1676 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1677 unsigned long r_type, unsigned long r_symndx,
1680 struct alpha_elf_got_entry *gotent;
1681 struct alpha_elf_got_entry **slot;
1684 slot = &h->got_entries;
1687 /* This is a local .got entry -- record for merge. */
1689 struct alpha_elf_got_entry **local_got_entries;
1691 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1692 if (!local_got_entries)
1695 Elf_Internal_Shdr *symtab_hdr;
1697 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1698 size = symtab_hdr->sh_info;
1699 size *= sizeof (struct alpha_elf_got_entry *);
1702 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1703 if (!local_got_entries)
1706 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1709 slot = &local_got_entries[r_symndx];
1712 for (gotent = *slot; gotent ; gotent = gotent->next)
1713 if (gotent->gotobj == abfd
1714 && gotent->reloc_type == r_type
1715 && gotent->addend == r_addend)
1723 amt = sizeof (struct alpha_elf_got_entry);
1724 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1728 gotent->gotobj = abfd;
1729 gotent->addend = r_addend;
1730 gotent->got_offset = -1;
1731 gotent->plt_offset = -1;
1732 gotent->use_count = 1;
1733 gotent->reloc_type = r_type;
1734 gotent->reloc_done = 0;
1735 gotent->reloc_xlated = 0;
1737 gotent->next = *slot;
1740 entry_size = alpha_got_entry_size (r_type);
1741 alpha_elf_tdata (abfd)->total_got_size += entry_size;
1743 alpha_elf_tdata(abfd)->local_got_size += entry_size;
1746 gotent->use_count += 1;
1752 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1754 return ((ah->root.type == STT_FUNC
1755 || ah->root.root.type == bfd_link_hash_undefweak
1756 || ah->root.root.type == bfd_link_hash_undefined)
1757 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1758 && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1761 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
1762 Don't do so for code sections. We want to keep ordering of LITERAL/LITUSE
1763 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
1764 relocs to be sorted. */
1767 elf64_alpha_sort_relocs_p (asection *sec)
1769 return (sec->flags & SEC_CODE) == 0;
1773 /* Handle dynamic relocations when doing an Alpha ELF link. */
1776 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1777 asection *sec, const Elf_Internal_Rela *relocs)
1781 Elf_Internal_Shdr *symtab_hdr;
1782 struct alpha_elf_link_hash_entry **sym_hashes;
1783 const Elf_Internal_Rela *rel, *relend;
1786 if (bfd_link_relocatable (info))
1789 /* Don't do anything special with non-loaded, non-alloced sections.
1790 In particular, any relocs in such sections should not affect GOT
1791 and PLT reference counting (ie. we don't allow them to create GOT
1792 or PLT entries), there's no possibility or desire to optimize TLS
1793 relocs, and there's not much point in propagating relocs to shared
1794 libs that the dynamic linker won't relocate. */
1795 if ((sec->flags & SEC_ALLOC) == 0)
1798 BFD_ASSERT (is_alpha_elf (abfd));
1800 dynobj = elf_hash_table (info)->dynobj;
1802 elf_hash_table (info)->dynobj = dynobj = abfd;
1805 symtab_hdr = &elf_symtab_hdr (abfd);
1806 sym_hashes = alpha_elf_sym_hashes (abfd);
1808 relend = relocs + sec->reloc_count;
1809 for (rel = relocs; rel < relend; ++rel)
1817 unsigned long r_symndx, r_type;
1818 struct alpha_elf_link_hash_entry *h;
1819 unsigned int gotent_flags;
1820 bfd_boolean maybe_dynamic;
1824 r_symndx = ELF64_R_SYM (rel->r_info);
1825 if (r_symndx < symtab_hdr->sh_info)
1829 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1831 while (h->root.root.type == bfd_link_hash_indirect
1832 || h->root.root.type == bfd_link_hash_warning)
1833 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1835 /* PR15323, ref flags aren't set for references in the same
1837 h->root.root.non_ir_ref = 1;
1838 h->root.ref_regular = 1;
1841 /* We can only get preliminary data on whether a symbol is
1842 locally or externally defined, as not all of the input files
1843 have yet been processed. Do something with what we know, as
1844 this may help reduce memory usage and processing time later. */
1845 maybe_dynamic = FALSE;
1846 if (h && ((bfd_link_pic (info)
1848 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1849 || !h->root.def_regular
1850 || h->root.root.type == bfd_link_hash_defweak))
1851 maybe_dynamic = TRUE;
1855 r_type = ELF64_R_TYPE (rel->r_info);
1856 addend = rel->r_addend;
1860 case R_ALPHA_LITERAL:
1861 need = NEED_GOT | NEED_GOT_ENTRY;
1863 /* Remember how this literal is used from its LITUSEs.
1864 This will be important when it comes to decide if we can
1865 create a .plt entry for a function symbol. */
1866 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
1867 if (rel->r_addend >= 1 && rel->r_addend <= 6)
1868 gotent_flags |= 1 << rel->r_addend;
1871 /* No LITUSEs -- presumably the address is used somehow. */
1872 if (gotent_flags == 0)
1873 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
1876 case R_ALPHA_GPDISP:
1877 case R_ALPHA_GPREL16:
1878 case R_ALPHA_GPREL32:
1879 case R_ALPHA_GPRELHIGH:
1880 case R_ALPHA_GPRELLOW:
1885 case R_ALPHA_REFLONG:
1886 case R_ALPHA_REFQUAD:
1887 if (bfd_link_pic (info) || maybe_dynamic)
1891 case R_ALPHA_TLSLDM:
1892 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1893 reloc to the STN_UNDEF (0) symbol so that they all match. */
1894 r_symndx = STN_UNDEF;
1896 maybe_dynamic = FALSE;
1900 case R_ALPHA_GOTDTPREL:
1901 need = NEED_GOT | NEED_GOT_ENTRY;
1904 case R_ALPHA_GOTTPREL:
1905 need = NEED_GOT | NEED_GOT_ENTRY;
1906 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
1907 if (bfd_link_pic (info))
1908 info->flags |= DF_STATIC_TLS;
1911 case R_ALPHA_TPREL64:
1912 if (bfd_link_dll (info))
1914 info->flags |= DF_STATIC_TLS;
1917 else if (maybe_dynamic)
1922 if (need & NEED_GOT)
1924 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1926 if (!elf64_alpha_create_got_section (abfd, info))
1931 if (need & NEED_GOT_ENTRY)
1933 struct alpha_elf_got_entry *gotent;
1935 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
1941 gotent->flags |= gotent_flags;
1944 gotent_flags |= h->flags;
1945 h->flags = gotent_flags;
1947 /* Make a guess as to whether a .plt entry is needed. */
1948 /* ??? It appears that we won't make it into
1949 adjust_dynamic_symbol for symbols that remain
1950 totally undefined. Copying this check here means
1951 we can create a plt entry for them too. */
1953 = (maybe_dynamic && elf64_alpha_want_plt (h));
1958 if (need & NEED_DYNREL)
1960 /* We need to create the section here now whether we eventually
1961 use it or not so that it gets mapped to an output section by
1962 the linker. If not used, we'll kill it in size_dynamic_sections. */
1965 sreloc = _bfd_elf_make_dynamic_reloc_section
1966 (sec, dynobj, 3, abfd, /*rela?*/ TRUE);
1974 /* Since we havn't seen all of the input symbols yet, we
1975 don't know whether we'll actually need a dynamic relocation
1976 entry for this reloc. So make a record of it. Once we
1977 find out if this thing needs dynamic relocation we'll
1978 expand the relocation sections by the appropriate amount. */
1980 struct alpha_elf_reloc_entry *rent;
1982 for (rent = h->reloc_entries; rent; rent = rent->next)
1983 if (rent->rtype == r_type && rent->srel == sreloc)
1988 amt = sizeof (struct alpha_elf_reloc_entry);
1989 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
1993 rent->srel = sreloc;
1994 rent->rtype = r_type;
1996 rent->reltext = (sec->flags & SEC_READONLY) != 0;
1998 rent->next = h->reloc_entries;
1999 h->reloc_entries = rent;
2004 else if (bfd_link_pic (info))
2006 /* If this is a shared library, and the section is to be
2007 loaded into memory, we need a RELATIVE reloc. */
2008 sreloc->size += sizeof (Elf64_External_Rela);
2009 if (sec->flags & SEC_READONLY)
2010 info->flags |= DF_TEXTREL;
2018 /* Return the section that should be marked against GC for a given
2022 elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info,
2023 Elf_Internal_Rela *rel,
2024 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
2026 /* These relocations don't really reference a symbol. Instead we store
2027 extra data in their addend slot. Ignore the symbol. */
2028 switch (ELF64_R_TYPE (rel->r_info))
2030 case R_ALPHA_LITUSE:
2031 case R_ALPHA_GPDISP:
2036 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2039 /* Update the got entry reference counts for the section being removed. */
2042 elf64_alpha_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2043 asection *sec, const Elf_Internal_Rela *relocs)
2045 Elf_Internal_Shdr *symtab_hdr;
2046 struct alpha_elf_link_hash_entry **sym_hashes;
2047 const Elf_Internal_Rela *rel, *relend;
2049 if (bfd_link_relocatable (info))
2052 symtab_hdr = &elf_symtab_hdr (abfd);
2053 sym_hashes = alpha_elf_sym_hashes (abfd);
2055 relend = relocs + sec->reloc_count;
2056 for (rel = relocs; rel < relend; rel++)
2058 unsigned long r_symndx, r_type;
2059 struct alpha_elf_link_hash_entry *h = NULL;
2060 struct alpha_elf_got_entry *gotent;
2062 r_symndx = ELF64_R_SYM (rel->r_info);
2063 if (r_symndx >= symtab_hdr->sh_info)
2065 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2066 while (h->root.root.type == bfd_link_hash_indirect
2067 || h->root.root.type == bfd_link_hash_warning)
2068 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2071 r_type = ELF64_R_TYPE (rel->r_info);
2074 case R_ALPHA_LITERAL:
2075 /* ??? Ignore re-computation of gotent_flags. We're not
2076 carrying a use-count for each bit in that mask. */
2079 case R_ALPHA_GOTDTPREL:
2080 case R_ALPHA_GOTTPREL:
2081 /* Fetch the got entry from the tables. */
2082 gotent = get_got_entry (abfd, h, r_type, r_symndx, rel->r_addend);
2084 /* The got entry *must* exist, since we should have created it
2085 before during check_relocs. Also note that get_got_entry
2086 assumed this was going to be another use, and so incremented
2087 the use count again. Thus the use count must be at least the
2088 one real use and the "use" we just added. */
2089 if (gotent == NULL || gotent->use_count < 2)
2094 gotent->use_count -= 2;
2105 /* Adjust a symbol defined by a dynamic object and referenced by a
2106 regular object. The current definition is in some section of the
2107 dynamic object, but we're not including those sections. We have to
2108 change the definition to something the rest of the link can
2112 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2113 struct elf_link_hash_entry *h)
2117 struct alpha_elf_link_hash_entry *ah;
2119 dynobj = elf_hash_table(info)->dynobj;
2120 ah = (struct alpha_elf_link_hash_entry *)h;
2122 /* Now that we've seen all of the input symbols, finalize our decision
2123 about whether this symbol should get a .plt entry. Irritatingly, it
2124 is common for folk to leave undefined symbols in shared libraries,
2125 and they still expect lazy binding; accept undefined symbols in lieu
2127 if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2129 h->needs_plt = TRUE;
2131 s = bfd_get_linker_section (dynobj, ".plt");
2132 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2135 /* We need one plt entry per got subsection. Delay allocation of
2136 the actual plt entries until size_plt_section, called from
2137 size_dynamic_sections or during relaxation. */
2142 h->needs_plt = FALSE;
2144 /* If this is a weak symbol, and there is a real definition, the
2145 processor independent code will have arranged for us to see the
2146 real definition first, and we can just use the same value. */
2147 if (h->u.weakdef != NULL)
2149 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2150 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2151 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2152 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2156 /* This is a reference to a symbol defined by a dynamic object which
2157 is not a function. The Alpha, since it uses .got entries for all
2158 symbols even in regular objects, does not need the hackery of a
2159 .dynbss section and COPY dynamic relocations. */
2164 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2167 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2168 const Elf_Internal_Sym *isym,
2169 bfd_boolean definition,
2170 bfd_boolean dynamic)
2172 if (!dynamic && definition)
2173 h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2174 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
2177 /* Symbol versioning can create new symbols, and make our old symbols
2178 indirect to the new ones. Consolidate the got and reloc information
2179 in these situations. */
2182 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2183 struct elf_link_hash_entry *dir,
2184 struct elf_link_hash_entry *ind)
2186 struct alpha_elf_link_hash_entry *hi
2187 = (struct alpha_elf_link_hash_entry *) ind;
2188 struct alpha_elf_link_hash_entry *hs
2189 = (struct alpha_elf_link_hash_entry *) dir;
2191 /* Do the merging in the superclass. */
2192 _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2194 /* Merge the flags. Whee. */
2195 hs->flags |= hi->flags;
2197 /* ??? It's unclear to me what's really supposed to happen when
2198 "merging" defweak and defined symbols, given that we don't
2199 actually throw away the defweak. This more-or-less copies
2200 the logic related to got and plt entries in the superclass. */
2201 if (ind->root.type != bfd_link_hash_indirect)
2204 /* Merge the .got entries. Cannibalize the old symbol's list in
2205 doing so, since we don't need it anymore. */
2207 if (hs->got_entries == NULL)
2208 hs->got_entries = hi->got_entries;
2211 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2213 gsh = hs->got_entries;
2214 for (gi = hi->got_entries; gi ; gi = gin)
2217 for (gs = gsh; gs ; gs = gs->next)
2218 if (gi->gotobj == gs->gotobj
2219 && gi->reloc_type == gs->reloc_type
2220 && gi->addend == gs->addend)
2222 gs->use_count += gi->use_count;
2225 gi->next = hs->got_entries;
2226 hs->got_entries = gi;
2230 hi->got_entries = NULL;
2232 /* And similar for the reloc entries. */
2234 if (hs->reloc_entries == NULL)
2235 hs->reloc_entries = hi->reloc_entries;
2238 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2240 rsh = hs->reloc_entries;
2241 for (ri = hi->reloc_entries; ri ; ri = rin)
2244 for (rs = rsh; rs ; rs = rs->next)
2245 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2247 rs->count += ri->count;
2250 ri->next = hs->reloc_entries;
2251 hs->reloc_entries = ri;
2255 hi->reloc_entries = NULL;
2258 /* Is it possible to merge two object file's .got tables? */
2261 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2263 int total = alpha_elf_tdata (a)->total_got_size;
2266 /* Trivial quick fallout test. */
2267 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2270 /* By their nature, local .got entries cannot be merged. */
2271 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2274 /* Failing the common trivial comparison, we must effectively
2275 perform the merge. Not actually performing the merge means that
2276 we don't have to store undo information in case we fail. */
2277 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2279 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2280 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2283 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2284 for (i = 0; i < n; ++i)
2286 struct alpha_elf_got_entry *ae, *be;
2287 struct alpha_elf_link_hash_entry *h;
2290 while (h->root.root.type == bfd_link_hash_indirect
2291 || h->root.root.type == bfd_link_hash_warning)
2292 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2294 for (be = h->got_entries; be ; be = be->next)
2296 if (be->use_count == 0)
2298 if (be->gotobj != b)
2301 for (ae = h->got_entries; ae ; ae = ae->next)
2303 && ae->reloc_type == be->reloc_type
2304 && ae->addend == be->addend)
2307 total += alpha_got_entry_size (be->reloc_type);
2308 if (total > MAX_GOT_SIZE)
2318 /* Actually merge two .got tables. */
2321 elf64_alpha_merge_gots (bfd *a, bfd *b)
2323 int total = alpha_elf_tdata (a)->total_got_size;
2326 /* Remember local expansion. */
2328 int e = alpha_elf_tdata (b)->local_got_size;
2330 alpha_elf_tdata (a)->local_got_size += e;
2333 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2335 struct alpha_elf_got_entry **local_got_entries;
2336 struct alpha_elf_link_hash_entry **hashes;
2337 Elf_Internal_Shdr *symtab_hdr;
2340 /* Let the local .got entries know they are part of a new subsegment. */
2341 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2342 if (local_got_entries)
2344 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2345 for (i = 0; i < n; ++i)
2347 struct alpha_elf_got_entry *ent;
2348 for (ent = local_got_entries[i]; ent; ent = ent->next)
2353 /* Merge the global .got entries. */
2354 hashes = alpha_elf_sym_hashes (bsub);
2355 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2357 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2358 for (i = 0; i < n; ++i)
2360 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2361 struct alpha_elf_link_hash_entry *h;
2364 while (h->root.root.type == bfd_link_hash_indirect
2365 || h->root.root.type == bfd_link_hash_warning)
2366 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2368 pbe = start = &h->got_entries;
2369 while ((be = *pbe) != NULL)
2371 if (be->use_count == 0)
2374 memset (be, 0xa5, sizeof (*be));
2377 if (be->gotobj != b)
2380 for (ae = *start; ae ; ae = ae->next)
2382 && ae->reloc_type == be->reloc_type
2383 && ae->addend == be->addend)
2385 ae->flags |= be->flags;
2386 ae->use_count += be->use_count;
2388 memset (be, 0xa5, sizeof (*be));
2392 total += alpha_got_entry_size (be->reloc_type);
2400 alpha_elf_tdata (bsub)->gotobj = a;
2402 alpha_elf_tdata (a)->total_got_size = total;
2404 /* Merge the two in_got chains. */
2409 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2412 alpha_elf_tdata (bsub)->in_got_link_next = b;
2416 /* Calculate the offsets for the got entries. */
2419 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2420 void * arg ATTRIBUTE_UNUSED)
2422 struct alpha_elf_got_entry *gotent;
2424 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2425 if (gotent->use_count > 0)
2427 struct alpha_elf_obj_tdata *td;
2428 bfd_size_type *plge;
2430 td = alpha_elf_tdata (gotent->gotobj);
2431 plge = &td->got->size;
2432 gotent->got_offset = *plge;
2433 *plge += alpha_got_entry_size (gotent->reloc_type);
2440 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2443 struct alpha_elf_link_hash_table * htab;
2445 htab = alpha_elf_hash_table (info);
2448 got_list = htab->got_list;
2450 /* First, zero out the .got sizes, as we may be recalculating the
2451 .got after optimizing it. */
2452 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2453 alpha_elf_tdata(i)->got->size = 0;
2455 /* Next, fill in the offsets for all the global entries. */
2456 alpha_elf_link_hash_traverse (htab,
2457 elf64_alpha_calc_got_offsets_for_symbol,
2460 /* Finally, fill in the offsets for the local entries. */
2461 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2463 bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2466 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2468 struct alpha_elf_got_entry **local_got_entries, *gotent;
2471 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2472 if (!local_got_entries)
2475 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2476 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2477 if (gotent->use_count > 0)
2479 gotent->got_offset = got_offset;
2480 got_offset += alpha_got_entry_size (gotent->reloc_type);
2484 alpha_elf_tdata(i)->got->size = got_offset;
2488 /* Constructs the gots. */
2491 elf64_alpha_size_got_sections (struct bfd_link_info *info,
2492 bfd_boolean may_merge)
2494 bfd *i, *got_list, *cur_got_obj = NULL;
2495 struct alpha_elf_link_hash_table * htab;
2497 htab = alpha_elf_hash_table (info);
2500 got_list = htab->got_list;
2502 /* On the first time through, pretend we have an existing got list
2503 consisting of all of the input files. */
2504 if (got_list == NULL)
2506 for (i = info->input_bfds; i ; i = i->link.next)
2510 if (! is_alpha_elf (i))
2513 this_got = alpha_elf_tdata (i)->gotobj;
2514 if (this_got == NULL)
2517 /* We are assuming no merging has yet occurred. */
2518 BFD_ASSERT (this_got == i);
2520 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2522 /* Yikes! A single object file has too many entries. */
2524 /* xgettext:c-format */
2525 (_("%B: .got subsegment exceeds 64K (size %d)"),
2526 i, alpha_elf_tdata (this_got)->total_got_size);
2530 if (got_list == NULL)
2531 got_list = this_got;
2533 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2534 cur_got_obj = this_got;
2537 /* Strange degenerate case of no got references. */
2538 if (got_list == NULL)
2541 htab->got_list = got_list;
2544 cur_got_obj = got_list;
2545 if (cur_got_obj == NULL)
2550 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2553 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2555 elf64_alpha_merge_gots (cur_got_obj, i);
2557 alpha_elf_tdata(i)->got->size = 0;
2558 i = alpha_elf_tdata(i)->got_link_next;
2559 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2564 i = alpha_elf_tdata(i)->got_link_next;
2569 /* Once the gots have been merged, fill in the got offsets for
2570 everything therein. */
2571 elf64_alpha_calc_got_offsets (info);
2577 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2580 asection *splt = (asection *) data;
2581 struct alpha_elf_got_entry *gotent;
2582 bfd_boolean saw_one = FALSE;
2584 /* If we didn't need an entry before, we still don't. */
2585 if (!h->root.needs_plt)
2588 /* For each LITERAL got entry still in use, allocate a plt entry. */
2589 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2590 if (gotent->reloc_type == R_ALPHA_LITERAL
2591 && gotent->use_count > 0)
2593 if (splt->size == 0)
2594 splt->size = PLT_HEADER_SIZE;
2595 gotent->plt_offset = splt->size;
2596 splt->size += PLT_ENTRY_SIZE;
2600 /* If there weren't any, there's no longer a need for the PLT entry. */
2602 h->root.needs_plt = FALSE;
2607 /* Called from relax_section to rebuild the PLT in light of potential changes
2608 in the function's status. */
2611 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2613 asection *splt, *spltrel, *sgotplt;
2614 unsigned long entries;
2616 struct alpha_elf_link_hash_table * htab;
2618 htab = alpha_elf_hash_table (info);
2622 dynobj = elf_hash_table(info)->dynobj;
2623 splt = bfd_get_linker_section (dynobj, ".plt");
2629 alpha_elf_link_hash_traverse (htab,
2630 elf64_alpha_size_plt_section_1, splt);
2632 /* Every plt entry requires a JMP_SLOT relocation. */
2633 spltrel = bfd_get_linker_section (dynobj, ".rela.plt");
2637 if (elf64_alpha_use_secureplt)
2638 entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2640 entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2642 spltrel->size = entries * sizeof (Elf64_External_Rela);
2644 /* When using the secureplt, we need two words somewhere in the data
2645 segment for the dynamic linker to tell us where to go. This is the
2646 entire contents of the .got.plt section. */
2647 if (elf64_alpha_use_secureplt)
2649 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
2650 sgotplt->size = entries ? 16 : 0;
2655 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2656 struct bfd_link_info *info)
2659 struct alpha_elf_link_hash_table * htab;
2661 if (bfd_link_relocatable (info))
2664 htab = alpha_elf_hash_table (info);
2668 if (!elf64_alpha_size_got_sections (info, TRUE))
2671 /* Allocate space for all of the .got subsections. */
2673 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2675 asection *s = alpha_elf_tdata(i)->got;
2678 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2679 if (s->contents == NULL)
2687 /* The number of dynamic relocations required by a static relocation. */
2690 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2694 /* May appear in GOT entries. */
2696 return (dynamic ? 2 : shared ? 1 : 0);
2697 case R_ALPHA_TLSLDM:
2699 case R_ALPHA_LITERAL:
2700 return dynamic || shared;
2701 case R_ALPHA_GOTTPREL:
2702 return dynamic || (shared && !pie);
2703 case R_ALPHA_GOTDTPREL:
2706 /* May appear in data sections. */
2707 case R_ALPHA_REFLONG:
2708 case R_ALPHA_REFQUAD:
2709 return dynamic || shared;
2710 case R_ALPHA_TPREL64:
2711 return dynamic || (shared && !pie);
2713 /* Everything else is illegal. We'll issue an error during
2714 relocate_section. */
2720 /* Work out the sizes of the dynamic relocation entries. */
2723 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2724 struct bfd_link_info *info)
2726 bfd_boolean dynamic;
2727 struct alpha_elf_reloc_entry *relent;
2728 unsigned long entries;
2730 /* If the symbol was defined as a common symbol in a regular object
2731 file, and there was no definition in any dynamic object, then the
2732 linker will have allocated space for the symbol in a common
2733 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2734 set. This is done for dynamic symbols in
2735 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2736 symbols, somehow. */
2737 if (!h->root.def_regular
2738 && h->root.ref_regular
2739 && !h->root.def_dynamic
2740 && (h->root.root.type == bfd_link_hash_defined
2741 || h->root.root.type == bfd_link_hash_defweak)
2742 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2743 h->root.def_regular = 1;
2745 /* If the symbol is dynamic, we'll need all the relocations in their
2746 natural form. If this is a shared object, and it has been forced
2747 local, we'll need the same number of RELATIVE relocations. */
2748 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2750 /* If the symbol is a hidden undefined weak, then we never have any
2751 relocations. Avoid the loop which may want to add RELATIVE relocs
2752 based on bfd_link_pic (info). */
2753 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2756 for (relent = h->reloc_entries; relent; relent = relent->next)
2758 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2759 bfd_link_pic (info),
2760 bfd_link_pie (info));
2763 relent->srel->size +=
2764 entries * sizeof (Elf64_External_Rela) * relent->count;
2765 if (relent->reltext)
2766 info->flags |= DT_TEXTREL;
2773 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2777 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2778 struct bfd_link_info *info)
2780 bfd_boolean dynamic;
2781 struct alpha_elf_got_entry *gotent;
2782 unsigned long entries;
2784 /* If we're using a plt for this symbol, then all of its relocations
2785 for its got entries go into .rela.plt. */
2786 if (h->root.needs_plt)
2789 /* If the symbol is dynamic, we'll need all the relocations in their
2790 natural form. If this is a shared object, and it has been forced
2791 local, we'll need the same number of RELATIVE relocations. */
2792 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2794 /* If the symbol is a hidden undefined weak, then we never have any
2795 relocations. Avoid the loop which may want to add RELATIVE relocs
2796 based on bfd_link_pic (info). */
2797 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2801 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2802 if (gotent->use_count > 0)
2803 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2804 bfd_link_pic (info),
2805 bfd_link_pie (info));
2809 bfd *dynobj = elf_hash_table(info)->dynobj;
2810 asection *srel = bfd_get_linker_section (dynobj, ".rela.got");
2811 BFD_ASSERT (srel != NULL);
2812 srel->size += sizeof (Elf64_External_Rela) * entries;
2818 /* Set the sizes of the dynamic relocation sections. */
2821 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2823 unsigned long entries;
2826 struct alpha_elf_link_hash_table * htab;
2828 htab = alpha_elf_hash_table (info);
2832 /* Shared libraries often require RELATIVE relocs, and some relocs
2833 require attention for the main application as well. */
2836 for (i = htab->got_list;
2837 i ; i = alpha_elf_tdata(i)->got_link_next)
2841 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2843 struct alpha_elf_got_entry **local_got_entries, *gotent;
2846 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2847 if (!local_got_entries)
2850 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2851 for (gotent = local_got_entries[k];
2852 gotent ; gotent = gotent->next)
2853 if (gotent->use_count > 0)
2854 entries += (alpha_dynamic_entries_for_reloc
2855 (gotent->reloc_type, 0, bfd_link_pic (info),
2856 bfd_link_pie (info)));
2860 dynobj = elf_hash_table(info)->dynobj;
2861 srel = bfd_get_linker_section (dynobj, ".rela.got");
2864 BFD_ASSERT (entries == 0);
2867 srel->size = sizeof (Elf64_External_Rela) * entries;
2869 /* Now do the non-local symbols. */
2870 alpha_elf_link_hash_traverse (htab,
2871 elf64_alpha_size_rela_got_1, info);
2874 /* Set the sizes of the dynamic sections. */
2877 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2878 struct bfd_link_info *info)
2883 struct alpha_elf_link_hash_table * htab;
2885 htab = alpha_elf_hash_table (info);
2889 dynobj = elf_hash_table(info)->dynobj;
2890 BFD_ASSERT(dynobj != NULL);
2892 if (elf_hash_table (info)->dynamic_sections_created)
2894 /* Set the contents of the .interp section to the interpreter. */
2895 if (bfd_link_executable (info) && !info->nointerp)
2897 s = bfd_get_linker_section (dynobj, ".interp");
2898 BFD_ASSERT (s != NULL);
2899 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2900 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2903 /* Now that we've seen all of the input files, we can decide which
2904 symbols need dynamic relocation entries and which don't. We've
2905 collected information in check_relocs that we can now apply to
2906 size the dynamic relocation sections. */
2907 alpha_elf_link_hash_traverse (htab,
2908 elf64_alpha_calc_dynrel_sizes, info);
2910 elf64_alpha_size_rela_got_section (info);
2911 elf64_alpha_size_plt_section (info);
2913 /* else we're not dynamic and by definition we don't need such things. */
2915 /* The check_relocs and adjust_dynamic_symbol entry points have
2916 determined the sizes of the various dynamic sections. Allocate
2919 for (s = dynobj->sections; s != NULL; s = s->next)
2923 if (!(s->flags & SEC_LINKER_CREATED))
2926 /* It's OK to base decisions on the section name, because none
2927 of the dynobj section names depend upon the input files. */
2928 name = bfd_get_section_name (dynobj, s);
2930 if (CONST_STRNEQ (name, ".rela"))
2934 if (strcmp (name, ".rela.plt") == 0)
2937 /* We use the reloc_count field as a counter if we need
2938 to copy relocs into the output file. */
2942 else if (! CONST_STRNEQ (name, ".got")
2943 && strcmp (name, ".plt") != 0
2944 && strcmp (name, ".dynbss") != 0)
2946 /* It's not one of our dynamic sections, so don't allocate space. */
2952 /* If we don't need this section, strip it from the output file.
2953 This is to handle .rela.bss and .rela.plt. We must create it
2954 in create_dynamic_sections, because it must be created before
2955 the linker maps input sections to output sections. The
2956 linker does that before adjust_dynamic_symbol is called, and
2957 it is that function which decides whether anything needs to
2958 go into these sections. */
2959 if (!CONST_STRNEQ (name, ".got"))
2960 s->flags |= SEC_EXCLUDE;
2962 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2964 /* Allocate memory for the section contents. */
2965 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2966 if (s->contents == NULL)
2971 if (elf_hash_table (info)->dynamic_sections_created)
2973 /* Add some entries to the .dynamic section. We fill in the
2974 values later, in elf64_alpha_finish_dynamic_sections, but we
2975 must add the entries now so that we get the correct size for
2976 the .dynamic section. The DT_DEBUG entry is filled in by the
2977 dynamic linker and used by the debugger. */
2978 #define add_dynamic_entry(TAG, VAL) \
2979 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2981 if (bfd_link_executable (info))
2983 if (!add_dynamic_entry (DT_DEBUG, 0))
2989 if (!add_dynamic_entry (DT_PLTGOT, 0)
2990 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2991 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2992 || !add_dynamic_entry (DT_JMPREL, 0))
2995 if (elf64_alpha_use_secureplt
2996 && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
3000 if (!add_dynamic_entry (DT_RELA, 0)
3001 || !add_dynamic_entry (DT_RELASZ, 0)
3002 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3005 if (info->flags & DF_TEXTREL)
3007 if (!add_dynamic_entry (DT_TEXTREL, 0))
3011 #undef add_dynamic_entry
3016 /* These functions do relaxation for Alpha ELF.
3018 Currently I'm only handling what I can do with existing compiler
3019 and assembler support, which means no instructions are removed,
3020 though some may be nopped. At this time GCC does not emit enough
3021 information to do all of the relaxing that is possible. It will
3022 take some not small amount of work for that to happen.
3024 There are a couple of interesting papers that I once read on this
3025 subject, that I cannot find references to at the moment, that
3026 related to Alpha in particular. They are by David Wall, then of
3029 struct alpha_relax_info
3034 Elf_Internal_Shdr *symtab_hdr;
3035 Elf_Internal_Rela *relocs, *relend;
3036 struct bfd_link_info *link_info;
3040 struct alpha_elf_link_hash_entry *h;
3041 struct alpha_elf_got_entry **first_gotent;
3042 struct alpha_elf_got_entry *gotent;
3043 bfd_boolean changed_contents;
3044 bfd_boolean changed_relocs;
3045 unsigned char other;
3048 static Elf_Internal_Rela *
3049 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
3050 Elf_Internal_Rela *relend,
3051 bfd_vma offset, int type)
3053 while (rel < relend)
3055 if (rel->r_offset == offset
3056 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
3064 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3065 Elf_Internal_Rela *irel, unsigned long r_type)
3068 bfd_signed_vma disp;
3070 /* Get the instruction. */
3071 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3073 if (insn >> 26 != OP_LDQ)
3075 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3077 /* xgettext:c-format */
3078 (_("%B: %A+0x%lx: warning: %s relocation against unexpected insn"),
3079 info->abfd, info->sec,
3080 (unsigned long) irel->r_offset, howto->name);
3084 /* Can't relax dynamic symbols. */
3085 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3088 /* Can't use local-exec relocations in shared libraries. */
3089 if (r_type == R_ALPHA_GOTTPREL
3090 && bfd_link_dll (info->link_info))
3093 if (r_type == R_ALPHA_LITERAL)
3095 /* Look for nice constant addresses. This includes the not-uncommon
3096 special case of 0 for undefweak symbols. */
3097 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3098 || (!bfd_link_pic (info->link_info)
3099 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3102 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3103 insn |= (symval & 0xffff);
3104 r_type = R_ALPHA_NONE;
3108 /* We may only create GPREL relocs during the second pass. */
3109 if (info->link_info->relax_pass == 0)
3112 disp = symval - info->gp;
3113 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3114 r_type = R_ALPHA_GPREL16;
3119 bfd_vma dtp_base, tp_base;
3121 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3122 dtp_base = alpha_get_dtprel_base (info->link_info);
3123 tp_base = alpha_get_tprel_base (info->link_info);
3124 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3126 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3130 case R_ALPHA_GOTDTPREL:
3131 r_type = R_ALPHA_DTPREL16;
3133 case R_ALPHA_GOTTPREL:
3134 r_type = R_ALPHA_TPREL16;
3142 if (disp < -0x8000 || disp >= 0x8000)
3145 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3146 info->changed_contents = TRUE;
3148 /* Reduce the use count on this got entry by one, possibly
3150 if (--info->gotent->use_count == 0)
3152 int sz = alpha_got_entry_size (r_type);
3153 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3155 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3158 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3159 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3160 info->changed_relocs = TRUE;
3162 /* ??? Search forward through this basic block looking for insns
3163 that use the target register. Stop after an insn modifying the
3164 register is seen, or after a branch or call.
3166 Any such memory load insn may be substituted by a load directly
3167 off the GP. This allows the memory load insn to be issued before
3168 the calculated GP register would otherwise be ready.
3170 Any such jsr insn can be replaced by a bsr if it is in range.
3172 This would mean that we'd have to _add_ relocations, the pain of
3173 which gives one pause. */
3179 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3181 /* If the function has the same gp, and we can identify that the
3182 function does not use its function pointer, we can eliminate the
3185 /* If the symbol is marked NOPV, we are being told the function never
3186 needs its procedure value. */
3187 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3190 /* If the symbol is marked STD_GP, we are being told the function does
3191 a normal ldgp in the first two words. */
3192 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3195 /* Otherwise, we may be able to identify a GP load in the first two
3196 words, which we can then skip. */
3199 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3202 /* Load the relocations from the section that the target symbol is in. */
3203 if (info->sec == info->tsec)
3205 tsec_relocs = info->relocs;
3206 tsec_relend = info->relend;
3211 tsec_relocs = (_bfd_elf_link_read_relocs
3212 (info->abfd, info->tsec, NULL,
3213 (Elf_Internal_Rela *) NULL,
3214 info->link_info->keep_memory));
3215 if (tsec_relocs == NULL)
3217 tsec_relend = tsec_relocs + info->tsec->reloc_count;
3218 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
3221 /* Recover the symbol's offset within the section. */
3222 ofs = (symval - info->tsec->output_section->vma
3223 - info->tsec->output_offset);
3225 /* Look for a GPDISP reloc. */
3226 gpdisp = (elf64_alpha_find_reloc_at_ofs
3227 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3229 if (!gpdisp || gpdisp->r_addend != 4)
3239 /* We've now determined that we can skip an initial gp load. Verify
3240 that the call and the target use the same gp. */
3241 if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3242 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3249 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3250 bfd_vma symval, Elf_Internal_Rela *irel)
3252 Elf_Internal_Rela *urel, *erel, *irelend = info->relend;
3254 bfd_signed_vma disp;
3257 bfd_boolean lit_reused = FALSE;
3258 bfd_boolean all_optimized = TRUE;
3259 bfd_boolean changed_contents;
3260 bfd_boolean changed_relocs;
3261 bfd_byte *contents = info->contents;
3262 bfd *abfd = info->abfd;
3263 bfd_vma sec_output_vma;
3264 unsigned int lit_insn;
3267 lit_insn = bfd_get_32 (abfd, contents + irel->r_offset);
3268 if (lit_insn >> 26 != OP_LDQ)
3271 /* xgettext:c-format */
3272 (_("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn"),
3274 (unsigned long) irel->r_offset);
3278 /* Can't relax dynamic symbols. */
3279 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3282 changed_contents = info->changed_contents;
3283 changed_relocs = info->changed_relocs;
3284 sec_output_vma = info->sec->output_section->vma + info->sec->output_offset;
3285 relax_pass = info->link_info->relax_pass;
3287 /* Summarize how this particular LITERAL is used. */
3288 for (erel = irel+1, flags = 0; erel < irelend; ++erel)
3290 if (ELF64_R_TYPE (erel->r_info) != R_ALPHA_LITUSE)
3292 if (erel->r_addend <= 6)
3293 flags |= 1 << erel->r_addend;
3296 /* A little preparation for the loop... */
3297 disp = symval - info->gp;
3299 for (urel = irel+1; urel < erel; ++urel)
3301 bfd_vma urel_r_offset = urel->r_offset;
3304 bfd_signed_vma xdisp;
3305 Elf_Internal_Rela nrel;
3307 insn = bfd_get_32 (abfd, contents + urel_r_offset);
3309 switch (urel->r_addend)
3311 case LITUSE_ALPHA_ADDR:
3313 /* This type is really just a placeholder to note that all
3314 uses cannot be optimized, but to still allow some. */
3315 all_optimized = FALSE;
3318 case LITUSE_ALPHA_BASE:
3319 /* We may only create GPREL relocs during the second pass. */
3320 if (relax_pass == 0)
3322 all_optimized = FALSE;
3326 /* We can always optimize 16-bit displacements. */
3328 /* Extract the displacement from the instruction, sign-extending
3329 it if necessary, then test whether it is within 16 or 32 bits
3330 displacement from GP. */
3331 insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3333 xdisp = disp + insn_disp;
3334 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3335 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3336 && xdisp < 0x7fff8000);
3340 /* Take the op code and dest from this insn, take the base
3341 register from the literal insn. Leave the offset alone. */
3342 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3343 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3344 changed_contents = TRUE;
3347 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3349 nrel.r_addend = irel->r_addend;
3351 /* As we adjust, move the reloc to the end so that we don't
3352 break the LITERAL+LITUSE chain. */
3356 changed_relocs = TRUE;
3359 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3360 else if (fits32 && !(flags & ~6))
3362 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3364 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3366 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3367 bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset);
3369 changed_contents = TRUE;
3371 /* Since all relocs must be optimized, don't bother swapping
3372 this relocation to the end. */
3373 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3375 urel->r_addend = irel->r_addend;
3376 changed_relocs = TRUE;
3379 all_optimized = FALSE;
3382 case LITUSE_ALPHA_BYTOFF:
3383 /* We can always optimize byte instructions. */
3385 /* FIXME: sanity check the insn for byte op. Check that the
3386 literal dest reg is indeed Rb in the byte insn. */
3388 insn &= ~ (unsigned) 0x001ff000;
3389 insn |= ((symval & 7) << 13) | 0x1000;
3390 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3391 changed_contents = TRUE;
3394 nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3397 /* As we adjust, move the reloc to the end so that we don't
3398 break the LITERAL+LITUSE chain. */
3402 changed_relocs = TRUE;
3405 case LITUSE_ALPHA_JSR:
3406 case LITUSE_ALPHA_TLSGD:
3407 case LITUSE_ALPHA_TLSLDM:
3408 case LITUSE_ALPHA_JSRDIRECT:
3410 bfd_vma optdest, org;
3411 bfd_signed_vma odisp;
3413 /* For undefined weak symbols, we're mostly interested in getting
3414 rid of the got entry whenever possible, so optimize this to a
3415 use of the zero register. */
3416 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3419 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3421 changed_contents = TRUE;
3425 /* If not zero, place to jump without needing pv. */
3426 optdest = elf64_alpha_relax_opt_call (info, symval);
3427 org = sec_output_vma + urel_r_offset + 4;
3428 odisp = (optdest ? optdest : symval) - org;
3430 if (odisp >= -0x400000 && odisp < 0x400000)
3432 Elf_Internal_Rela *xrel;
3434 /* Preserve branch prediction call stack when possible. */
3435 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3436 insn = (OP_BSR << 26) | (insn & 0x03e00000);
3438 insn = (OP_BR << 26) | (insn & 0x03e00000);
3439 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3440 changed_contents = TRUE;
3443 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3445 nrel.r_addend = irel->r_addend;
3448 nrel.r_addend += optdest - symval;
3450 all_optimized = FALSE;
3452 /* Kill any HINT reloc that might exist for this insn. */
3453 xrel = (elf64_alpha_find_reloc_at_ofs
3454 (info->relocs, info->relend, urel_r_offset,
3457 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3459 /* As we adjust, move the reloc to the end so that we don't
3460 break the LITERAL+LITUSE chain. */
3465 info->changed_relocs = TRUE;
3468 all_optimized = FALSE;
3470 /* Even if the target is not in range for a direct branch,
3471 if we share a GP, we can eliminate the gp reload. */
3474 Elf_Internal_Rela *gpdisp
3475 = (elf64_alpha_find_reloc_at_ofs
3476 (info->relocs, irelend, urel_r_offset + 4,
3480 bfd_byte *p_ldah = contents + gpdisp->r_offset;
3481 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3482 unsigned int ldah = bfd_get_32 (abfd, p_ldah);
3483 unsigned int lda = bfd_get_32 (abfd, p_lda);
3485 /* Verify that the instruction is "ldah $29,0($26)".
3486 Consider a function that ends in a noreturn call,
3487 and that the next function begins with an ldgp,
3488 and that by accident there is no padding between.
3489 In that case the insn would use $27 as the base. */
3490 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3492 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_ldah);
3493 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda);
3495 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3496 changed_contents = TRUE;
3497 changed_relocs = TRUE;
3506 /* If we reused the literal instruction, we must have optimized all. */
3507 BFD_ASSERT(!lit_reused || all_optimized);
3509 /* If all cases were optimized, we can reduce the use count on this
3510 got entry by one, possibly eliminating it. */
3513 if (--info->gotent->use_count == 0)
3515 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3516 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3518 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3521 /* If the literal instruction is no longer needed (it may have been
3522 reused. We can eliminate it. */
3523 /* ??? For now, I don't want to deal with compacting the section,
3524 so just nop it out. */
3527 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3528 changed_relocs = TRUE;
3530 bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset);
3531 changed_contents = TRUE;
3535 info->changed_contents = changed_contents;
3536 info->changed_relocs = changed_relocs;
3538 if (all_optimized || relax_pass == 0)
3540 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3544 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3545 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3548 unsigned int insn, tlsgd_reg;
3549 Elf_Internal_Rela *gpdisp, *hint;
3550 bfd_boolean dynamic, use_gottprel;
3551 unsigned long new_symndx;
3553 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3555 /* If a TLS symbol is accessed using IE at least once, there is no point
3556 to use dynamic model for it. */
3557 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3560 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3561 then we might as well relax to IE. */
3562 else if (bfd_link_pic (info->link_info) && !dynamic
3563 && (info->link_info->flags & DF_STATIC_TLS))
3566 /* Otherwise we must be building an executable to do anything. */
3567 else if (bfd_link_pic (info->link_info))
3570 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3571 the matching LITUSE_TLS relocations. */
3572 if (irel + 2 >= info->relend)
3574 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3575 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3576 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3579 /* There must be a GPDISP relocation positioned immediately after the
3580 LITUSE relocation. */
3581 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3582 irel[2].r_offset + 4, R_ALPHA_GPDISP);
3586 pos[0] = info->contents + irel[0].r_offset;
3587 pos[1] = info->contents + irel[1].r_offset;
3588 pos[2] = info->contents + irel[2].r_offset;
3589 pos[3] = info->contents + gpdisp->r_offset;
3590 pos[4] = pos[3] + gpdisp->r_addend;
3592 /* Beware of the compiler hoisting part of the sequence out a loop
3593 and adjusting the destination register for the TLSGD insn. If this
3594 happens, there will be a move into $16 before the JSR insn, so only
3595 transformations of the first insn pair should use this register. */
3596 tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3597 tlsgd_reg = (tlsgd_reg >> 21) & 31;
3599 /* Generally, the positions are not allowed to be out of order, lest the
3600 modified insn sequence have different register lifetimes. We can make
3601 an exception when pos 1 is adjacent to pos 0. */
3602 if (pos[1] + 4 == pos[0])
3604 bfd_byte *tmp = pos[0];
3608 if (pos[1] >= pos[2] || pos[2] >= pos[3])
3611 /* Reduce the use count on the LITERAL relocation. Do this before we
3612 smash the symndx when we adjust the relocations below. */
3614 struct alpha_elf_got_entry *lit_gotent;
3615 struct alpha_elf_link_hash_entry *lit_h;
3618 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3619 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3620 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3622 while (lit_h->root.root.type == bfd_link_hash_indirect
3623 || lit_h->root.root.type == bfd_link_hash_warning)
3624 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3626 for (lit_gotent = lit_h->got_entries; lit_gotent ;
3627 lit_gotent = lit_gotent->next)
3628 if (lit_gotent->gotobj == info->gotobj
3629 && lit_gotent->reloc_type == R_ALPHA_LITERAL
3630 && lit_gotent->addend == irel[1].r_addend)
3632 BFD_ASSERT (lit_gotent);
3634 if (--lit_gotent->use_count == 0)
3636 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3637 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3643 lda $16,x($gp) !tlsgd!1
3644 ldq $27,__tls_get_addr($gp) !literal!1
3645 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3646 ldah $29,0($26) !gpdisp!2
3647 lda $29,0($29) !gpdisp!2
3649 ldq $16,x($gp) !gottprel
3654 or the first pair to
3655 lda $16,x($gp) !tprel
3658 ldah $16,x($gp) !tprelhi
3659 lda $16,x($16) !tprello
3663 use_gottprel = FALSE;
3664 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3666 /* Some compilers warn about a Boolean-looking expression being
3667 used in a switch. The explicit cast silences them. */
3668 switch ((int) (!dynamic && !bfd_link_pic (info->link_info)))
3673 bfd_signed_vma disp;
3675 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3676 tp_base = alpha_get_tprel_base (info->link_info);
3677 disp = symval - tp_base;
3679 if (disp >= -0x8000 && disp < 0x8000)
3681 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3682 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3683 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3685 irel[0].r_offset = pos[0] - info->contents;
3686 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3687 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3690 else if (disp >= -(bfd_signed_vma) 0x80000000
3691 && disp < (bfd_signed_vma) 0x7fff8000
3692 && pos[0] + 4 == pos[1])
3694 insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3695 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3696 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3697 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3699 irel[0].r_offset = pos[0] - info->contents;
3700 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3701 irel[1].r_offset = pos[1] - info->contents;
3702 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3709 use_gottprel = TRUE;
3711 insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3712 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3713 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3715 irel[0].r_offset = pos[0] - info->contents;
3716 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3717 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3721 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3723 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3724 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3726 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3728 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3729 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3731 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3732 irel[2].r_offset, R_ALPHA_HINT);
3734 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3736 info->changed_contents = TRUE;
3737 info->changed_relocs = TRUE;
3739 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3740 if (--info->gotent->use_count == 0)
3742 int sz = alpha_got_entry_size (info->gotent->reloc_type);
3743 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3745 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3748 /* If we've switched to a GOTTPREL relocation, increment the reference
3749 count on that got entry. */
3752 struct alpha_elf_got_entry *tprel_gotent;
3754 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3755 tprel_gotent = tprel_gotent->next)
3756 if (tprel_gotent->gotobj == info->gotobj
3757 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3758 && tprel_gotent->addend == irel->r_addend)
3761 tprel_gotent->use_count++;
3764 if (info->gotent->use_count == 0)
3765 tprel_gotent = info->gotent;
3768 tprel_gotent = (struct alpha_elf_got_entry *)
3769 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3773 tprel_gotent->next = *info->first_gotent;
3774 *info->first_gotent = tprel_gotent;
3776 tprel_gotent->gotobj = info->gotobj;
3777 tprel_gotent->addend = irel->r_addend;
3778 tprel_gotent->got_offset = -1;
3779 tprel_gotent->reloc_done = 0;
3780 tprel_gotent->reloc_xlated = 0;
3783 tprel_gotent->use_count = 1;
3784 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3792 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3793 struct bfd_link_info *link_info, bfd_boolean *again)
3795 Elf_Internal_Shdr *symtab_hdr;
3796 Elf_Internal_Rela *internal_relocs;
3797 Elf_Internal_Rela *irel, *irelend;
3798 Elf_Internal_Sym *isymbuf = NULL;
3799 struct alpha_elf_got_entry **local_got_entries;
3800 struct alpha_relax_info info;
3801 struct alpha_elf_link_hash_table * htab;
3804 htab = alpha_elf_hash_table (link_info);
3808 /* There's nothing to change, yet. */
3811 if (bfd_link_relocatable (link_info)
3812 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3813 != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3814 || sec->reloc_count == 0)
3817 BFD_ASSERT (is_alpha_elf (abfd));
3818 relax_pass = link_info->relax_pass;
3820 /* Make sure our GOT and PLT tables are up-to-date. */
3821 if (htab->relax_trip != link_info->relax_trip)
3823 htab->relax_trip = link_info->relax_trip;
3825 /* This should never fail after the initial round, since the only error
3826 is GOT overflow, and relaxation only shrinks the table. However, we
3827 may only merge got sections during the first pass. If we merge
3828 sections after we've created GPREL relocs, the GP for the merged
3829 section backs up which may put the relocs out of range. */
3830 if (!elf64_alpha_size_got_sections (link_info, relax_pass == 0))
3832 if (elf_hash_table (link_info)->dynamic_sections_created)
3834 elf64_alpha_size_plt_section (link_info);
3835 elf64_alpha_size_rela_got_section (link_info);
3839 symtab_hdr = &elf_symtab_hdr (abfd);
3840 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3842 /* Load the relocations for this section. */
3843 internal_relocs = (_bfd_elf_link_read_relocs
3844 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3845 link_info->keep_memory));
3846 if (internal_relocs == NULL)
3849 memset(&info, 0, sizeof (info));
3852 info.link_info = link_info;
3853 info.symtab_hdr = symtab_hdr;
3854 info.relocs = internal_relocs;
3855 info.relend = irelend = internal_relocs + sec->reloc_count;
3857 /* Find the GP for this object. Do not store the result back via
3858 _bfd_set_gp_value, since this could change again before final. */
3859 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3862 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3863 info.gp = (sgot->output_section->vma
3864 + sgot->output_offset
3868 /* Get the section contents. */
3869 if (elf_section_data (sec)->this_hdr.contents != NULL)
3870 info.contents = elf_section_data (sec)->this_hdr.contents;
3873 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3877 for (irel = internal_relocs; irel < irelend; irel++)
3880 struct alpha_elf_got_entry *gotent;
3881 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3882 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3884 /* Early exit for unhandled or unrelaxable relocations. */
3885 if (r_type != R_ALPHA_LITERAL)
3887 /* We complete everything except LITERAL in the first pass. */
3888 if (relax_pass != 0)
3890 if (r_type == R_ALPHA_TLSLDM)
3892 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3893 reloc to the STN_UNDEF (0) symbol so that they all match. */
3894 r_symndx = STN_UNDEF;
3896 else if (r_type != R_ALPHA_GOTDTPREL
3897 && r_type != R_ALPHA_GOTTPREL
3898 && r_type != R_ALPHA_TLSGD)
3902 /* Get the value of the symbol referred to by the reloc. */
3903 if (r_symndx < symtab_hdr->sh_info)
3905 /* A local symbol. */
3906 Elf_Internal_Sym *isym;
3908 /* Read this BFD's local symbols. */
3909 if (isymbuf == NULL)
3911 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3912 if (isymbuf == NULL)
3913 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3914 symtab_hdr->sh_info, 0,
3916 if (isymbuf == NULL)
3920 isym = isymbuf + r_symndx;
3922 /* Given the symbol for a TLSLDM reloc is ignored, this also
3923 means forcing the symbol value to the tp base. */
3924 if (r_type == R_ALPHA_TLSLDM)
3926 info.tsec = bfd_abs_section_ptr;
3927 symval = alpha_get_tprel_base (info.link_info);
3931 symval = isym->st_value;
3932 if (isym->st_shndx == SHN_UNDEF)
3934 else if (isym->st_shndx == SHN_ABS)
3935 info.tsec = bfd_abs_section_ptr;
3936 else if (isym->st_shndx == SHN_COMMON)
3937 info.tsec = bfd_com_section_ptr;
3939 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3943 info.other = isym->st_other;
3944 if (local_got_entries)
3945 info.first_gotent = &local_got_entries[r_symndx];
3948 info.first_gotent = &info.gotent;
3955 struct alpha_elf_link_hash_entry *h;
3957 indx = r_symndx - symtab_hdr->sh_info;
3958 h = alpha_elf_sym_hashes (abfd)[indx];
3959 BFD_ASSERT (h != NULL);
3961 while (h->root.root.type == bfd_link_hash_indirect
3962 || h->root.root.type == bfd_link_hash_warning)
3963 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3965 /* If the symbol is undefined, we can't do anything with it. */
3966 if (h->root.root.type == bfd_link_hash_undefined)
3969 /* If the symbol isn't defined in the current module,
3970 again we can't do anything. */
3971 if (h->root.root.type == bfd_link_hash_undefweak)
3973 info.tsec = bfd_abs_section_ptr;
3976 else if (!h->root.def_regular)
3978 /* Except for TLSGD relocs, which can sometimes be
3979 relaxed to GOTTPREL relocs. */
3980 if (r_type != R_ALPHA_TLSGD)
3982 info.tsec = bfd_abs_section_ptr;
3987 info.tsec = h->root.root.u.def.section;
3988 symval = h->root.root.u.def.value;
3992 info.other = h->root.other;
3993 info.first_gotent = &h->got_entries;
3996 /* Search for the got entry to be used by this relocation. */
3997 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3998 if (gotent->gotobj == info.gotobj
3999 && gotent->reloc_type == r_type
4000 && gotent->addend == irel->r_addend)
4002 info.gotent = gotent;
4004 symval += info.tsec->output_section->vma + info.tsec->output_offset;
4005 symval += irel->r_addend;
4009 case R_ALPHA_LITERAL:
4010 BFD_ASSERT(info.gotent != NULL);
4012 /* If there exist LITUSE relocations immediately following, this
4013 opens up all sorts of interesting optimizations, because we
4014 now know every location that this address load is used. */
4015 if (irel+1 < irelend
4016 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
4018 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
4023 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
4028 case R_ALPHA_GOTDTPREL:
4029 case R_ALPHA_GOTTPREL:
4030 BFD_ASSERT(info.gotent != NULL);
4031 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
4036 case R_ALPHA_TLSLDM:
4037 BFD_ASSERT(info.gotent != NULL);
4038 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
4039 r_type == R_ALPHA_TLSGD))
4046 && symtab_hdr->contents != (unsigned char *) isymbuf)
4048 if (!link_info->keep_memory)
4052 /* Cache the symbols for elf_link_input_bfd. */
4053 symtab_hdr->contents = (unsigned char *) isymbuf;
4057 if (info.contents != NULL
4058 && elf_section_data (sec)->this_hdr.contents != info.contents)
4060 if (!info.changed_contents && !link_info->keep_memory)
4061 free (info.contents);
4064 /* Cache the section contents for elf_link_input_bfd. */
4065 elf_section_data (sec)->this_hdr.contents = info.contents;
4069 if (elf_section_data (sec)->relocs != internal_relocs)
4071 if (!info.changed_relocs)
4072 free (internal_relocs);
4074 elf_section_data (sec)->relocs = internal_relocs;
4077 *again = info.changed_contents || info.changed_relocs;
4083 && symtab_hdr->contents != (unsigned char *) isymbuf)
4085 if (info.contents != NULL
4086 && elf_section_data (sec)->this_hdr.contents != info.contents)
4087 free (info.contents);
4088 if (internal_relocs != NULL
4089 && elf_section_data (sec)->relocs != internal_relocs)
4090 free (internal_relocs);
4094 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4095 into the next available slot in SREL. */
4098 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4099 asection *sec, asection *srel, bfd_vma offset,
4100 long dynindx, long rtype, bfd_vma addend)
4102 Elf_Internal_Rela outrel;
4105 BFD_ASSERT (srel != NULL);
4107 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4108 outrel.r_addend = addend;
4110 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4111 if ((offset | 1) != (bfd_vma) -1)
4112 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4114 memset (&outrel, 0, sizeof (outrel));
4116 loc = srel->contents;
4117 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4118 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4119 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4122 /* Relocate an Alpha ELF section for a relocatable link.
4124 We don't have to change anything unless the reloc is against a section
4125 symbol, in which case we have to adjust according to where the section
4126 symbol winds up in the output section. */
4129 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4130 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4131 bfd *input_bfd, asection *input_section,
4132 bfd_byte *contents ATTRIBUTE_UNUSED,
4133 Elf_Internal_Rela *relocs,
4134 Elf_Internal_Sym *local_syms,
4135 asection **local_sections)
4137 unsigned long symtab_hdr_sh_info;
4138 Elf_Internal_Rela *rel;
4139 Elf_Internal_Rela *relend;
4140 struct elf_link_hash_entry **sym_hashes;
4141 bfd_boolean ret_val = TRUE;
4143 symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4144 sym_hashes = elf_sym_hashes (input_bfd);
4146 relend = relocs + input_section->reloc_count;
4147 for (rel = relocs; rel < relend; rel++)
4149 unsigned long r_symndx;
4150 Elf_Internal_Sym *sym;
4152 unsigned long r_type;
4154 r_type = ELF64_R_TYPE (rel->r_info);
4155 if (r_type >= R_ALPHA_max)
4158 /* xgettext:c-format */
4159 (_("%B: unknown relocation type %d"),
4160 input_bfd, (int) r_type);
4161 bfd_set_error (bfd_error_bad_value);
4166 /* The symbol associated with GPDISP and LITUSE is
4167 immaterial. Only the addend is significant. */
4168 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4171 r_symndx = ELF64_R_SYM (rel->r_info);
4172 if (r_symndx < symtab_hdr_sh_info)
4174 sym = local_syms + r_symndx;
4175 sec = local_sections[r_symndx];
4179 struct elf_link_hash_entry *h;
4181 h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4183 while (h->root.type == bfd_link_hash_indirect
4184 || h->root.type == bfd_link_hash_warning)
4185 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4187 if (h->root.type != bfd_link_hash_defined
4188 && h->root.type != bfd_link_hash_defweak)
4192 sec = h->root.u.def.section;
4195 if (sec != NULL && discarded_section (sec))
4196 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4198 elf64_alpha_howto_table + r_type, 0,
4201 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4202 rel->r_addend += sec->output_offset;
4208 /* Relocate an Alpha ELF section. */
4211 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4212 bfd *input_bfd, asection *input_section,
4213 bfd_byte *contents, Elf_Internal_Rela *relocs,
4214 Elf_Internal_Sym *local_syms,
4215 asection **local_sections)
4217 Elf_Internal_Shdr *symtab_hdr;
4218 Elf_Internal_Rela *rel;
4219 Elf_Internal_Rela *relend;
4220 asection *sgot, *srel, *srelgot;
4221 bfd *dynobj, *gotobj;
4222 bfd_vma gp, tp_base, dtp_base;
4223 struct alpha_elf_got_entry **local_got_entries;
4224 bfd_boolean ret_val;
4226 BFD_ASSERT (is_alpha_elf (input_bfd));
4228 /* Handle relocatable links with a smaller loop. */
4229 if (bfd_link_relocatable (info))
4230 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4231 input_section, contents, relocs,
4232 local_syms, local_sections);
4234 /* This is a final link. */
4238 symtab_hdr = &elf_symtab_hdr (input_bfd);
4240 dynobj = elf_hash_table (info)->dynobj;
4242 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
4246 if (input_section->flags & SEC_ALLOC)
4248 const char *section_name;
4249 section_name = (bfd_elf_string_from_elf_section
4250 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4251 _bfd_elf_single_rel_hdr (input_section)->sh_name));
4252 BFD_ASSERT(section_name != NULL);
4253 srel = bfd_get_linker_section (dynobj, section_name);
4258 /* Find the gp value for this input bfd. */
4259 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4262 sgot = alpha_elf_tdata (gotobj)->got;
4263 gp = _bfd_get_gp_value (gotobj);
4266 gp = (sgot->output_section->vma
4267 + sgot->output_offset
4269 _bfd_set_gp_value (gotobj, gp);
4278 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4280 if (elf_hash_table (info)->tls_sec != NULL)
4282 dtp_base = alpha_get_dtprel_base (info);
4283 tp_base = alpha_get_tprel_base (info);
4286 dtp_base = tp_base = 0;
4288 relend = relocs + input_section->reloc_count;
4289 for (rel = relocs; rel < relend; rel++)
4291 struct alpha_elf_link_hash_entry *h = NULL;
4292 struct alpha_elf_got_entry *gotent;
4293 bfd_reloc_status_type r;
4294 reloc_howto_type *howto;
4295 unsigned long r_symndx;
4296 Elf_Internal_Sym *sym = NULL;
4297 asection *sec = NULL;
4300 bfd_boolean dynamic_symbol_p;
4301 bfd_boolean unresolved_reloc = FALSE;
4302 bfd_boolean undef_weak_ref = FALSE;
4303 unsigned long r_type;
4305 r_type = ELF64_R_TYPE(rel->r_info);
4306 if (r_type >= R_ALPHA_max)
4309 /* xgettext:c-format */
4310 (_("%B: unknown relocation type %d"),
4311 input_bfd, (int) r_type);
4312 bfd_set_error (bfd_error_bad_value);
4317 howto = elf64_alpha_howto_table + r_type;
4318 r_symndx = ELF64_R_SYM(rel->r_info);
4320 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4321 reloc to the STN_UNDEF (0) symbol so that they all match. */
4322 if (r_type == R_ALPHA_TLSLDM)
4323 r_symndx = STN_UNDEF;
4325 if (r_symndx < symtab_hdr->sh_info)
4328 sym = local_syms + r_symndx;
4329 sec = local_sections[r_symndx];
4331 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4333 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4334 this is hackery from relax_section. Force the value to
4335 be the tls module base. */
4336 if (r_symndx == STN_UNDEF
4337 && (r_type == R_ALPHA_TLSLDM
4338 || r_type == R_ALPHA_GOTTPREL
4339 || r_type == R_ALPHA_TPREL64
4340 || r_type == R_ALPHA_TPRELHI
4341 || r_type == R_ALPHA_TPRELLO
4342 || r_type == R_ALPHA_TPREL16))
4345 if (local_got_entries)
4346 gotent = local_got_entries[r_symndx];
4350 /* Need to adjust local GOT entries' addends for SEC_MERGE
4351 unless it has been done already. */
4352 if ((sec->flags & SEC_MERGE)
4353 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4354 && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4356 && !gotent->reloc_xlated)
4358 struct alpha_elf_got_entry *ent;
4360 for (ent = gotent; ent; ent = ent->next)
4362 ent->reloc_xlated = 1;
4363 if (ent->use_count == 0)
4367 _bfd_merged_section_offset (output_bfd, &msec,
4368 elf_section_data (sec)->
4370 sym->st_value + ent->addend);
4371 ent->addend -= sym->st_value;
4372 ent->addend += msec->output_section->vma
4373 + msec->output_offset
4374 - sec->output_section->vma
4375 - sec->output_offset;
4379 dynamic_symbol_p = FALSE;
4383 bfd_boolean warned, ignored;
4384 struct elf_link_hash_entry *hh;
4385 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4387 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4388 r_symndx, symtab_hdr, sym_hashes,
4390 unresolved_reloc, warned, ignored);
4396 && ! unresolved_reloc
4397 && hh->root.type == bfd_link_hash_undefweak)
4398 undef_weak_ref = TRUE;
4400 h = (struct alpha_elf_link_hash_entry *) hh;
4401 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4402 gotent = h->got_entries;
4405 if (sec != NULL && discarded_section (sec))
4406 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4407 rel, 1, relend, howto, 0, contents);
4409 addend = rel->r_addend;
4412 /* Search for the proper got entry. */
4413 for (; gotent ; gotent = gotent->next)
4414 if (gotent->gotobj == gotobj
4415 && gotent->reloc_type == r_type
4416 && gotent->addend == addend)
4421 case R_ALPHA_GPDISP:
4423 bfd_byte *p_ldah, *p_lda;
4425 BFD_ASSERT(gp != 0);
4427 value = (input_section->output_section->vma
4428 + input_section->output_offset
4431 p_ldah = contents + rel->r_offset;
4432 p_lda = p_ldah + rel->r_addend;
4434 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4439 case R_ALPHA_LITERAL:
4440 BFD_ASSERT(sgot != NULL);
4441 BFD_ASSERT(gp != 0);
4442 BFD_ASSERT(gotent != NULL);
4443 BFD_ASSERT(gotent->use_count >= 1);
4445 if (!gotent->reloc_done)
4447 gotent->reloc_done = 1;
4449 bfd_put_64 (output_bfd, value,
4450 sgot->contents + gotent->got_offset);
4452 /* If the symbol has been forced local, output a
4453 RELATIVE reloc, otherwise it will be handled in
4454 finish_dynamic_symbol. */
4455 if (bfd_link_pic (info)
4456 && !dynamic_symbol_p
4458 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4459 gotent->got_offset, 0,
4460 R_ALPHA_RELATIVE, value);
4463 value = (sgot->output_section->vma
4464 + sgot->output_offset
4465 + gotent->got_offset);
4469 case R_ALPHA_GPREL32:
4470 case R_ALPHA_GPREL16:
4471 case R_ALPHA_GPRELLOW:
4472 if (dynamic_symbol_p)
4475 /* xgettext:c-format */
4476 (_("%B: gp-relative relocation against dynamic symbol %s"),
4477 input_bfd, h->root.root.root.string);
4480 BFD_ASSERT(gp != 0);
4484 case R_ALPHA_GPRELHIGH:
4485 if (dynamic_symbol_p)
4488 /* xgettext:c-format */
4489 (_("%B: gp-relative relocation against dynamic symbol %s"),
4490 input_bfd, h->root.root.root.string);
4493 BFD_ASSERT(gp != 0);
4495 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4499 /* A call to a dynamic symbol is definitely out of range of
4500 the 16-bit displacement. Don't bother writing anything. */
4501 if (dynamic_symbol_p)
4506 /* The regular PC-relative stuff measures from the start of
4507 the instruction rather than the end. */
4511 case R_ALPHA_BRADDR:
4512 if (dynamic_symbol_p)
4515 /* xgettext:c-format */
4516 (_("%B: pc-relative relocation against dynamic symbol %s"),
4517 input_bfd, h->root.root.root.string);
4520 /* The regular PC-relative stuff measures from the start of
4521 the instruction rather than the end. */
4530 /* The regular PC-relative stuff measures from the start of
4531 the instruction rather than the end. */
4534 /* The source and destination gp must be the same. Note that
4535 the source will always have an assigned gp, since we forced
4536 one in check_relocs, but that the destination may not, as
4537 it might not have had any relocations at all. Also take
4538 care not to crash if H is an undefined symbol. */
4539 if (h != NULL && sec != NULL
4540 && alpha_elf_tdata (sec->owner)->gotobj
4541 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4544 /* xgettext:c-format */
4545 (_("%B: change in gp: BRSGP %s"),
4546 input_bfd, h->root.root.root.string);
4550 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4552 other = h->root.other;
4554 other = sym->st_other;
4555 switch (other & STO_ALPHA_STD_GPLOAD)
4557 case STO_ALPHA_NOPV:
4559 case STO_ALPHA_STD_GPLOAD:
4564 name = h->root.root.root.string;
4567 name = (bfd_elf_string_from_elf_section
4568 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4570 name = _("<unknown>");
4571 else if (name[0] == 0)
4572 name = bfd_section_name (input_bfd, sec);
4575 /* xgettext:c-format */
4576 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4585 case R_ALPHA_REFLONG:
4586 case R_ALPHA_REFQUAD:
4587 case R_ALPHA_DTPREL64:
4588 case R_ALPHA_TPREL64:
4590 long dynindx, dyntype = r_type;
4593 /* Careful here to remember RELATIVE relocations for global
4594 variables for symbolic shared objects. */
4596 if (dynamic_symbol_p)
4598 BFD_ASSERT(h->root.dynindx != -1);
4599 dynindx = h->root.dynindx;
4601 addend = 0, value = 0;
4603 else if (r_type == R_ALPHA_DTPREL64)
4605 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4609 else if (r_type == R_ALPHA_TPREL64)
4611 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4612 if (!bfd_link_dll (info))
4618 dynaddend = value - dtp_base;
4620 else if (bfd_link_pic (info)
4621 && r_symndx != STN_UNDEF
4622 && (input_section->flags & SEC_ALLOC)
4624 && !(unresolved_reloc
4625 && (_bfd_elf_section_offset (output_bfd, info,
4630 if (r_type == R_ALPHA_REFLONG)
4633 /* xgettext:c-format */
4634 (_("%B: unhandled dynamic relocation against %s"),
4636 h->root.root.root.string);
4640 dyntype = R_ALPHA_RELATIVE;
4646 if (input_section->flags & SEC_ALLOC)
4647 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4648 srel, rel->r_offset, dynindx,
4649 dyntype, dynaddend);
4653 case R_ALPHA_SREL16:
4654 case R_ALPHA_SREL32:
4655 case R_ALPHA_SREL64:
4656 if (dynamic_symbol_p)
4659 /* xgettext:c-format */
4660 (_("%B: pc-relative relocation against dynamic symbol %s"),
4661 input_bfd, h->root.root.root.string);
4664 else if (bfd_link_pic (info)
4668 /* xgettext:c-format */
4669 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4670 input_bfd, h->root.root.root.string);
4675 /* ??? .eh_frame references to discarded sections will be smashed
4676 to relocations against SHN_UNDEF. The .eh_frame format allows
4677 NULL to be encoded as 0 in any format, so this works here. */
4678 if (r_symndx == STN_UNDEF
4679 || (unresolved_reloc
4680 && _bfd_elf_section_offset (output_bfd, info,
4682 rel->r_offset) == (bfd_vma) -1))
4683 howto = (elf64_alpha_howto_table
4684 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4687 case R_ALPHA_TLSLDM:
4688 /* Ignore the symbol for the relocation. The result is always
4689 the current module. */
4690 dynamic_symbol_p = 0;
4694 if (!gotent->reloc_done)
4696 gotent->reloc_done = 1;
4698 /* Note that the module index for the main program is 1. */
4699 bfd_put_64 (output_bfd,
4700 !bfd_link_pic (info) && !dynamic_symbol_p,
4701 sgot->contents + gotent->got_offset);
4703 /* If the symbol has been forced local, output a
4704 DTPMOD64 reloc, otherwise it will be handled in
4705 finish_dynamic_symbol. */
4706 if (bfd_link_pic (info) && !dynamic_symbol_p)
4707 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4708 gotent->got_offset, 0,
4709 R_ALPHA_DTPMOD64, 0);
4711 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4715 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4718 bfd_put_64 (output_bfd, value,
4719 sgot->contents + gotent->got_offset + 8);
4722 value = (sgot->output_section->vma
4723 + sgot->output_offset
4724 + gotent->got_offset);
4728 case R_ALPHA_DTPRELHI:
4729 case R_ALPHA_DTPRELLO:
4730 case R_ALPHA_DTPREL16:
4731 if (dynamic_symbol_p)
4734 /* xgettext:c-format */
4735 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4736 input_bfd, h->root.root.root.string);
4739 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4741 if (r_type == R_ALPHA_DTPRELHI)
4742 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4745 case R_ALPHA_TPRELHI:
4746 case R_ALPHA_TPRELLO:
4747 case R_ALPHA_TPREL16:
4748 if (bfd_link_dll (info))
4751 /* xgettext:c-format */
4752 (_("%B: TLS local exec code cannot be linked into shared objects"),
4756 else if (dynamic_symbol_p)
4759 /* xgettext:c-format */
4760 (_("%B: tp-relative relocation against dynamic symbol %s"),
4761 input_bfd, h->root.root.root.string);
4764 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4766 if (r_type == R_ALPHA_TPRELHI)
4767 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4770 case R_ALPHA_GOTDTPREL:
4771 case R_ALPHA_GOTTPREL:
4772 BFD_ASSERT(sgot != NULL);
4773 BFD_ASSERT(gp != 0);
4774 BFD_ASSERT(gotent != NULL);
4775 BFD_ASSERT(gotent->use_count >= 1);
4777 if (!gotent->reloc_done)
4779 gotent->reloc_done = 1;
4781 if (dynamic_symbol_p)
4785 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4786 if (r_type == R_ALPHA_GOTDTPREL)
4788 else if (!bfd_link_pic (info))
4792 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4793 gotent->got_offset, 0,
4799 bfd_put_64 (output_bfd, value,
4800 sgot->contents + gotent->got_offset);
4803 value = (sgot->output_section->vma
4804 + sgot->output_offset
4805 + gotent->got_offset);
4811 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4812 contents, rel->r_offset, value, 0);
4821 case bfd_reloc_overflow:
4825 /* Don't warn if the overflow is due to pc relative reloc
4826 against discarded section. Section optimization code should
4829 if (r_symndx < symtab_hdr->sh_info
4830 && sec != NULL && howto->pc_relative
4831 && discarded_section (sec))
4838 name = (bfd_elf_string_from_elf_section
4839 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4843 name = bfd_section_name (input_bfd, sec);
4845 (*info->callbacks->reloc_overflow)
4846 (info, (h ? &h->root.root : NULL), name, howto->name,
4847 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4852 case bfd_reloc_outofrange:
4860 /* Finish up dynamic symbol handling. We set the contents of various
4861 dynamic sections here. */
4864 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4865 struct elf_link_hash_entry *h,
4866 Elf_Internal_Sym *sym)
4868 struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4869 bfd *dynobj = elf_hash_table(info)->dynobj;
4873 /* Fill in the .plt entry for this symbol. */
4874 asection *splt, *sgot, *srel;
4875 Elf_Internal_Rela outrel;
4877 bfd_vma got_addr, plt_addr;
4879 struct alpha_elf_got_entry *gotent;
4881 BFD_ASSERT (h->dynindx != -1);
4883 splt = bfd_get_linker_section (dynobj, ".plt");
4884 BFD_ASSERT (splt != NULL);
4885 srel = bfd_get_linker_section (dynobj, ".rela.plt");
4886 BFD_ASSERT (srel != NULL);
4888 for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4889 if (gotent->reloc_type == R_ALPHA_LITERAL
4890 && gotent->use_count > 0)
4895 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4896 BFD_ASSERT (sgot != NULL);
4898 BFD_ASSERT (gotent->got_offset != -1);
4899 BFD_ASSERT (gotent->plt_offset != -1);
4901 got_addr = (sgot->output_section->vma
4902 + sgot->output_offset
4903 + gotent->got_offset);
4904 plt_addr = (splt->output_section->vma
4905 + splt->output_offset
4906 + gotent->plt_offset);
4908 plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4910 /* Fill in the entry in the procedure linkage table. */
4911 if (elf64_alpha_use_secureplt)
4913 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4914 insn = INSN_AD (INSN_BR, 31, disp);
4915 bfd_put_32 (output_bfd, insn,
4916 splt->contents + gotent->plt_offset);
4918 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4919 / NEW_PLT_ENTRY_SIZE);
4923 disp = -(gotent->plt_offset + 4);
4924 insn = INSN_AD (INSN_BR, 28, disp);
4925 bfd_put_32 (output_bfd, insn,
4926 splt->contents + gotent->plt_offset);
4927 bfd_put_32 (output_bfd, INSN_UNOP,
4928 splt->contents + gotent->plt_offset + 4);
4929 bfd_put_32 (output_bfd, INSN_UNOP,
4930 splt->contents + gotent->plt_offset + 8);
4932 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4933 / OLD_PLT_ENTRY_SIZE);
4936 /* Fill in the entry in the .rela.plt section. */
4937 outrel.r_offset = got_addr;
4938 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4939 outrel.r_addend = 0;
4941 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4942 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4944 /* Fill in the entry in the .got. */
4945 bfd_put_64 (output_bfd, plt_addr,
4946 sgot->contents + gotent->got_offset);
4949 else if (alpha_elf_dynamic_symbol_p (h, info))
4951 /* Fill in the dynamic relocations for this symbol's .got entries. */
4953 struct alpha_elf_got_entry *gotent;
4955 srel = bfd_get_linker_section (dynobj, ".rela.got");
4956 BFD_ASSERT (srel != NULL);
4958 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4960 gotent = gotent->next)
4965 if (gotent->use_count == 0)
4968 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4970 r_type = gotent->reloc_type;
4973 case R_ALPHA_LITERAL:
4974 r_type = R_ALPHA_GLOB_DAT;
4977 r_type = R_ALPHA_DTPMOD64;
4979 case R_ALPHA_GOTDTPREL:
4980 r_type = R_ALPHA_DTPREL64;
4982 case R_ALPHA_GOTTPREL:
4983 r_type = R_ALPHA_TPREL64;
4985 case R_ALPHA_TLSLDM:
4990 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4991 gotent->got_offset, h->dynindx,
4992 r_type, gotent->addend);
4994 if (gotent->reloc_type == R_ALPHA_TLSGD)
4995 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4996 gotent->got_offset + 8, h->dynindx,
4997 R_ALPHA_DTPREL64, gotent->addend);
5001 /* Mark some specially defined symbols as absolute. */
5002 if (h == elf_hash_table (info)->hdynamic
5003 || h == elf_hash_table (info)->hgot
5004 || h == elf_hash_table (info)->hplt)
5005 sym->st_shndx = SHN_ABS;
5010 /* Finish up the dynamic sections. */
5013 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
5014 struct bfd_link_info *info)
5019 dynobj = elf_hash_table (info)->dynobj;
5020 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5022 if (elf_hash_table (info)->dynamic_sections_created)
5024 asection *splt, *sgotplt, *srelaplt;
5025 Elf64_External_Dyn *dyncon, *dynconend;
5026 bfd_vma plt_vma, gotplt_vma;
5028 splt = bfd_get_linker_section (dynobj, ".plt");
5029 srelaplt = bfd_get_linker_section (dynobj, ".rela.plt");
5030 BFD_ASSERT (splt != NULL && sdyn != NULL);
5032 plt_vma = splt->output_section->vma + splt->output_offset;
5035 if (elf64_alpha_use_secureplt)
5037 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
5038 BFD_ASSERT (sgotplt != NULL);
5039 if (sgotplt->size > 0)
5040 gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
5043 dyncon = (Elf64_External_Dyn *) sdyn->contents;
5044 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5045 for (; dyncon < dynconend; dyncon++)
5047 Elf_Internal_Dyn dyn;
5049 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5055 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
5058 dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
5061 dyn.d_un.d_ptr = srelaplt ? (srelaplt->output_section->vma
5062 + srelaplt->output_offset) : 0;
5066 /* My interpretation of the TIS v1.1 ELF document indicates
5067 that RELASZ should not include JMPREL. This is not what
5068 the rest of the BFD does. It is, however, what the
5069 glibc ld.so wants. Do this fixup here until we found
5070 out who is right. */
5072 dyn.d_un.d_val -= srelaplt->size;
5076 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5079 /* Initialize the plt header. */
5085 if (elf64_alpha_use_secureplt)
5087 ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
5089 insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
5090 bfd_put_32 (output_bfd, insn, splt->contents);
5092 insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
5093 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5095 insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
5096 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5098 insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5099 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5101 insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5102 bfd_put_32 (output_bfd, insn, splt->contents + 16);
5104 insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5105 bfd_put_32 (output_bfd, insn, splt->contents + 20);
5107 insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5108 bfd_put_32 (output_bfd, insn, splt->contents + 24);
5110 insn = INSN_AB (INSN_JMP, 31, 27);
5111 bfd_put_32 (output_bfd, insn, splt->contents + 28);
5113 insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5114 bfd_put_32 (output_bfd, insn, splt->contents + 32);
5118 insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */
5119 bfd_put_32 (output_bfd, insn, splt->contents);
5121 insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5122 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5125 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5127 insn = INSN_AB (INSN_JMP, 27, 27);
5128 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5130 /* The next two words will be filled in by ld.so. */
5131 bfd_put_64 (output_bfd, 0, splt->contents + 16);
5132 bfd_put_64 (output_bfd, 0, splt->contents + 24);
5135 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5142 /* We need to use a special link routine to handle the .mdebug section.
5143 We need to merge all instances of these sections together, not write
5144 them all out sequentially. */
5147 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5150 struct bfd_link_order *p;
5151 asection *mdebug_sec;
5152 struct ecoff_debug_info debug;
5153 const struct ecoff_debug_swap *swap
5154 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5155 HDRR *symhdr = &debug.symbolic_header;
5156 void * mdebug_handle = NULL;
5157 struct alpha_elf_link_hash_table * htab;
5159 htab = alpha_elf_hash_table (info);
5163 /* Go through the sections and collect the mdebug information. */
5165 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5167 if (strcmp (o->name, ".mdebug") == 0)
5169 struct extsym_info einfo;
5171 /* We have found the .mdebug section in the output file.
5172 Look through all the link_orders comprising it and merge
5173 the information together. */
5174 symhdr->magic = swap->sym_magic;
5175 /* FIXME: What should the version stamp be? */
5177 symhdr->ilineMax = 0;
5181 symhdr->isymMax = 0;
5182 symhdr->ioptMax = 0;
5183 symhdr->iauxMax = 0;
5185 symhdr->issExtMax = 0;
5188 symhdr->iextMax = 0;
5190 /* We accumulate the debugging information itself in the
5191 debug_info structure. */
5193 debug.external_dnr = NULL;
5194 debug.external_pdr = NULL;
5195 debug.external_sym = NULL;
5196 debug.external_opt = NULL;
5197 debug.external_aux = NULL;
5199 debug.ssext = debug.ssext_end = NULL;
5200 debug.external_fdr = NULL;
5201 debug.external_rfd = NULL;
5202 debug.external_ext = debug.external_ext_end = NULL;
5204 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5205 if (mdebug_handle == NULL)
5214 static const char * const name[] =
5216 ".text", ".init", ".fini", ".data",
5217 ".rodata", ".sdata", ".sbss", ".bss"
5219 static const int sc[] = { scText, scInit, scFini, scData,
5220 scRData, scSData, scSBss, scBss };
5223 esym.cobol_main = 0;
5227 esym.asym.iss = issNil;
5228 esym.asym.st = stLocal;
5229 esym.asym.reserved = 0;
5230 esym.asym.index = indexNil;
5231 for (i = 0; i < 8; i++)
5233 esym.asym.sc = sc[i];
5234 s = bfd_get_section_by_name (abfd, name[i]);
5237 esym.asym.value = s->vma;
5238 last = s->vma + s->size;
5241 esym.asym.value = last;
5243 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5249 for (p = o->map_head.link_order;
5250 p != (struct bfd_link_order *) NULL;
5253 asection *input_section;
5255 const struct ecoff_debug_swap *input_swap;
5256 struct ecoff_debug_info input_debug;
5260 if (p->type != bfd_indirect_link_order)
5262 if (p->type == bfd_data_link_order)
5267 input_section = p->u.indirect.section;
5268 input_bfd = input_section->owner;
5270 if (! is_alpha_elf (input_bfd))
5271 /* I don't know what a non ALPHA ELF bfd would be
5272 doing with a .mdebug section, but I don't really
5273 want to deal with it. */
5276 input_swap = (get_elf_backend_data (input_bfd)
5277 ->elf_backend_ecoff_debug_swap);
5279 BFD_ASSERT (p->size == input_section->size);
5281 /* The ECOFF linking code expects that we have already
5282 read in the debugging information and set up an
5283 ecoff_debug_info structure, so we do that now. */
5284 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5288 if (! (bfd_ecoff_debug_accumulate
5289 (mdebug_handle, abfd, &debug, swap, input_bfd,
5290 &input_debug, input_swap, info)))
5293 /* Loop through the external symbols. For each one with
5294 interesting information, try to find the symbol in
5295 the linker global hash table and save the information
5296 for the output external symbols. */
5297 eraw_src = (char *) input_debug.external_ext;
5298 eraw_end = (eraw_src
5299 + (input_debug.symbolic_header.iextMax
5300 * input_swap->external_ext_size));
5302 eraw_src < eraw_end;
5303 eraw_src += input_swap->external_ext_size)
5307 struct alpha_elf_link_hash_entry *h;
5309 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5310 if (ext.asym.sc == scNil
5311 || ext.asym.sc == scUndefined
5312 || ext.asym.sc == scSUndefined)
5315 name = input_debug.ssext + ext.asym.iss;
5316 h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5317 if (h == NULL || h->esym.ifd != -2)
5323 < input_debug.symbolic_header.ifdMax);
5324 ext.ifd = input_debug.ifdmap[ext.ifd];
5330 /* Free up the information we just read. */
5331 free (input_debug.line);
5332 free (input_debug.external_dnr);
5333 free (input_debug.external_pdr);
5334 free (input_debug.external_sym);
5335 free (input_debug.external_opt);
5336 free (input_debug.external_aux);
5337 free (input_debug.ss);
5338 free (input_debug.ssext);
5339 free (input_debug.external_fdr);
5340 free (input_debug.external_rfd);
5341 free (input_debug.external_ext);
5343 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5344 elf_link_input_bfd ignores this section. */
5345 input_section->flags &=~ SEC_HAS_CONTENTS;
5348 /* Build the external symbol information. */
5351 einfo.debug = &debug;
5353 einfo.failed = FALSE;
5354 elf_link_hash_traverse (elf_hash_table (info),
5355 elf64_alpha_output_extsym,
5360 /* Set the size of the .mdebug section. */
5361 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5363 /* Skip this section later on (I don't think this currently
5364 matters, but someday it might). */
5365 o->map_head.link_order = (struct bfd_link_order *) NULL;
5371 /* Invoke the regular ELF backend linker to do all the work. */
5372 if (! bfd_elf_final_link (abfd, info))
5375 /* Now write out the computed sections. */
5377 /* The .got subsections... */
5379 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5380 for (i = htab->got_list;
5382 i = alpha_elf_tdata(i)->got_link_next)
5386 /* elf_bfd_final_link already did everything in dynobj. */
5390 sgot = alpha_elf_tdata(i)->got;
5391 if (! bfd_set_section_contents (abfd, sgot->output_section,
5393 (file_ptr) sgot->output_offset,
5399 if (mdebug_sec != (asection *) NULL)
5401 BFD_ASSERT (abfd->output_has_begun);
5402 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5404 mdebug_sec->filepos))
5407 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5413 static enum elf_reloc_type_class
5414 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5415 const asection *rel_sec ATTRIBUTE_UNUSED,
5416 const Elf_Internal_Rela *rela)
5418 switch ((int) ELF64_R_TYPE (rela->r_info))
5420 case R_ALPHA_RELATIVE:
5421 return reloc_class_relative;
5422 case R_ALPHA_JMP_SLOT:
5423 return reloc_class_plt;
5425 return reloc_class_copy;
5427 return reloc_class_normal;
5431 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5433 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5434 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5435 { NULL, 0, 0, 0, 0 }
5438 /* ECOFF swapping routines. These are used when dealing with the
5439 .mdebug section, which is in the ECOFF debugging format. Copied
5440 from elf32-mips.c. */
5441 static const struct ecoff_debug_swap
5442 elf64_alpha_ecoff_debug_swap =
5444 /* Symbol table magic number. */
5446 /* Alignment of debugging information. E.g., 4. */
5448 /* Sizes of external symbolic information. */
5449 sizeof (struct hdr_ext),
5450 sizeof (struct dnr_ext),
5451 sizeof (struct pdr_ext),
5452 sizeof (struct sym_ext),
5453 sizeof (struct opt_ext),
5454 sizeof (struct fdr_ext),
5455 sizeof (struct rfd_ext),
5456 sizeof (struct ext_ext),
5457 /* Functions to swap in external symbolic data. */
5466 _bfd_ecoff_swap_tir_in,
5467 _bfd_ecoff_swap_rndx_in,
5468 /* Functions to swap out external symbolic data. */
5477 _bfd_ecoff_swap_tir_out,
5478 _bfd_ecoff_swap_rndx_out,
5479 /* Function to read in symbolic data. */
5480 elf64_alpha_read_ecoff_info
5483 /* Use a non-standard hash bucket size of 8. */
5485 static const struct elf_size_info alpha_elf_size_info =
5487 sizeof (Elf64_External_Ehdr),
5488 sizeof (Elf64_External_Phdr),
5489 sizeof (Elf64_External_Shdr),
5490 sizeof (Elf64_External_Rel),
5491 sizeof (Elf64_External_Rela),
5492 sizeof (Elf64_External_Sym),
5493 sizeof (Elf64_External_Dyn),
5494 sizeof (Elf_External_Note),
5498 ELFCLASS64, EV_CURRENT,
5499 bfd_elf64_write_out_phdrs,
5500 bfd_elf64_write_shdrs_and_ehdr,
5501 bfd_elf64_checksum_contents,
5502 bfd_elf64_write_relocs,
5503 bfd_elf64_swap_symbol_in,
5504 bfd_elf64_swap_symbol_out,
5505 bfd_elf64_slurp_reloc_table,
5506 bfd_elf64_slurp_symbol_table,
5507 bfd_elf64_swap_dyn_in,
5508 bfd_elf64_swap_dyn_out,
5509 bfd_elf64_swap_reloc_in,
5510 bfd_elf64_swap_reloc_out,
5511 bfd_elf64_swap_reloca_in,
5512 bfd_elf64_swap_reloca_out
5515 #define TARGET_LITTLE_SYM alpha_elf64_vec
5516 #define TARGET_LITTLE_NAME "elf64-alpha"
5517 #define ELF_ARCH bfd_arch_alpha
5518 #define ELF_TARGET_ID ALPHA_ELF_DATA
5519 #define ELF_MACHINE_CODE EM_ALPHA
5520 #define ELF_MAXPAGESIZE 0x10000
5521 #define ELF_COMMONPAGESIZE 0x2000
5523 #define bfd_elf64_bfd_link_hash_table_create \
5524 elf64_alpha_bfd_link_hash_table_create
5526 #define bfd_elf64_bfd_reloc_type_lookup \
5527 elf64_alpha_bfd_reloc_type_lookup
5528 #define bfd_elf64_bfd_reloc_name_lookup \
5529 elf64_alpha_bfd_reloc_name_lookup
5530 #define elf_info_to_howto \
5531 elf64_alpha_info_to_howto
5533 #define bfd_elf64_mkobject \
5534 elf64_alpha_mkobject
5535 #define elf_backend_object_p \
5536 elf64_alpha_object_p
5538 #define elf_backend_section_from_shdr \
5539 elf64_alpha_section_from_shdr
5540 #define elf_backend_section_flags \
5541 elf64_alpha_section_flags
5542 #define elf_backend_fake_sections \
5543 elf64_alpha_fake_sections
5545 #define bfd_elf64_bfd_is_local_label_name \
5546 elf64_alpha_is_local_label_name
5547 #define bfd_elf64_find_nearest_line \
5548 elf64_alpha_find_nearest_line
5549 #define bfd_elf64_bfd_relax_section \
5550 elf64_alpha_relax_section
5552 #define elf_backend_add_symbol_hook \
5553 elf64_alpha_add_symbol_hook
5554 #define elf_backend_relocs_compatible \
5555 _bfd_elf_relocs_compatible
5556 #define elf_backend_sort_relocs_p \
5557 elf64_alpha_sort_relocs_p
5558 #define elf_backend_check_relocs \
5559 elf64_alpha_check_relocs
5560 #define elf_backend_create_dynamic_sections \
5561 elf64_alpha_create_dynamic_sections
5562 #define elf_backend_adjust_dynamic_symbol \
5563 elf64_alpha_adjust_dynamic_symbol
5564 #define elf_backend_merge_symbol_attribute \
5565 elf64_alpha_merge_symbol_attribute
5566 #define elf_backend_copy_indirect_symbol \
5567 elf64_alpha_copy_indirect_symbol
5568 #define elf_backend_always_size_sections \
5569 elf64_alpha_always_size_sections
5570 #define elf_backend_size_dynamic_sections \
5571 elf64_alpha_size_dynamic_sections
5572 #define elf_backend_omit_section_dynsym \
5573 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5574 #define elf_backend_relocate_section \
5575 elf64_alpha_relocate_section
5576 #define elf_backend_finish_dynamic_symbol \
5577 elf64_alpha_finish_dynamic_symbol
5578 #define elf_backend_finish_dynamic_sections \
5579 elf64_alpha_finish_dynamic_sections
5580 #define bfd_elf64_bfd_final_link \
5581 elf64_alpha_final_link
5582 #define elf_backend_reloc_type_class \
5583 elf64_alpha_reloc_type_class
5585 #define elf_backend_can_gc_sections 1
5586 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5587 #define elf_backend_gc_sweep_hook elf64_alpha_gc_sweep_hook
5589 #define elf_backend_ecoff_debug_swap \
5590 &elf64_alpha_ecoff_debug_swap
5592 #define elf_backend_size_info \
5595 #define elf_backend_special_sections \
5596 elf64_alpha_special_sections
5598 /* A few constants that determine how the .plt section is set up. */
5599 #define elf_backend_want_got_plt 0
5600 #define elf_backend_plt_readonly 0
5601 #define elf_backend_want_plt_sym 1
5602 #define elf_backend_got_header_size 0
5604 #include "elf64-target.h"
5606 /* FreeBSD support. */
5608 #undef TARGET_LITTLE_SYM
5609 #define TARGET_LITTLE_SYM alpha_elf64_fbsd_vec
5610 #undef TARGET_LITTLE_NAME
5611 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5613 #define ELF_OSABI ELFOSABI_FREEBSD
5615 /* The kernel recognizes executables as valid only if they carry a
5616 "FreeBSD" label in the ELF header. So we put this label on all
5617 executables and (for simplicity) also all other object files. */
5620 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5621 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5623 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5625 i_ehdrp = elf_elfheader (abfd);
5627 /* Put an ABI label supported by FreeBSD >= 4.1. */
5628 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5629 #ifdef OLD_FREEBSD_ABI_LABEL
5630 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5631 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5635 #undef elf_backend_post_process_headers
5636 #define elf_backend_post_process_headers \
5637 elf64_alpha_fbsd_post_process_headers
5640 #define elf64_bed elf64_alpha_fbsd_bed
5642 #include "elf64-target.h"