1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
4 Free Software Foundation, Inc.
5 Contributed by Richard Henderson <rth@tamu.edu>.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
25 /* We need a published ABI spec for this. Until one comes out, don't
26 assume this'll remain unchanged forever. */
33 #include "elf/alpha.h"
37 #define NO_COFF_RELOCS
38 #define NO_COFF_SYMBOLS
39 #define NO_COFF_LINENOS
41 /* Get the ECOFF swapping routines. Needed for the debug information. */
42 #include "coff/internal.h"
44 #include "coff/symconst.h"
45 #include "coff/ecoff.h"
46 #include "coff/alpha.h"
51 #include "ecoffswap.h"
54 /* Instruction data for plt generation and relaxation. */
62 #define INSN_LDA (OP_LDA << 26)
63 #define INSN_LDAH (OP_LDAH << 26)
64 #define INSN_LDQ (OP_LDQ << 26)
65 #define INSN_BR (OP_BR << 26)
67 #define INSN_ADDQ 0x40000400
68 #define INSN_RDUNIQ 0x0000009e
69 #define INSN_SUBQ 0x40000520
70 #define INSN_S4SUBQ 0x40000560
71 #define INSN_UNOP 0x2ffe0000
73 #define INSN_JSR 0x68004000
74 #define INSN_JMP 0x68000000
75 #define INSN_JSR_MASK 0xfc00c000
77 #define INSN_A(I,A) (I | (A << 21))
78 #define INSN_AB(I,A,B) (I | (A << 21) | (B << 16))
79 #define INSN_ABC(I,A,B,C) (I | (A << 21) | (B << 16) | C)
80 #define INSN_ABO(I,A,B,O) (I | (A << 21) | (B << 16) | ((O) & 0xffff))
81 #define INSN_AD(I,A,D) (I | (A << 21) | (((D) >> 2) & 0x1fffff))
85 /* Set by ld emulation. Putting this into the link_info or hash structure
86 is simply working too hard. */
88 bfd_boolean elf64_alpha_use_secureplt = TRUE;
90 bfd_boolean elf64_alpha_use_secureplt = FALSE;
93 #define OLD_PLT_HEADER_SIZE 32
94 #define OLD_PLT_ENTRY_SIZE 12
95 #define NEW_PLT_HEADER_SIZE 36
96 #define NEW_PLT_ENTRY_SIZE 4
98 #define PLT_HEADER_SIZE \
99 (elf64_alpha_use_secureplt ? NEW_PLT_HEADER_SIZE : OLD_PLT_HEADER_SIZE)
100 #define PLT_ENTRY_SIZE \
101 (elf64_alpha_use_secureplt ? NEW_PLT_ENTRY_SIZE : OLD_PLT_ENTRY_SIZE)
103 #define MAX_GOT_SIZE (64*1024)
105 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
108 /* Used to implement multiple .got subsections. */
109 struct alpha_elf_got_entry
111 struct alpha_elf_got_entry *next;
113 /* Which .got subsection? */
116 /* The addend in effect for this entry. */
119 /* The .got offset for this entry. */
122 /* The .plt offset for this entry. */
125 /* How many references to this entry? */
128 /* The relocation type of this entry. */
129 unsigned char reloc_type;
131 /* How a LITERAL is used. */
134 /* Have we initialized the dynamic relocation for this entry? */
135 unsigned char reloc_done;
137 /* Have we adjusted this entry for SEC_MERGE? */
138 unsigned char reloc_xlated;
141 struct alpha_elf_reloc_entry
143 struct alpha_elf_reloc_entry *next;
145 /* Which .reloc section? */
148 /* What kind of relocation? */
151 /* Is this against read-only section? */
152 unsigned int reltext : 1;
154 /* How many did we find? */
158 struct alpha_elf_link_hash_entry
160 struct elf_link_hash_entry root;
162 /* External symbol information. */
165 /* Cumulative flags for all the .got entries. */
168 /* Contexts in which a literal was referenced. */
169 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
170 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
171 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
172 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
173 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
174 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
175 #define ALPHA_ELF_LINK_HASH_LU_JSRDIRECT 0x40
176 #define ALPHA_ELF_LINK_HASH_LU_PLT 0x38
177 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x80
179 /* Used to implement multiple .got subsections. */
180 struct alpha_elf_got_entry *got_entries;
182 /* Used to count non-got, non-plt relocations for delayed sizing
183 of relocation sections. */
184 struct alpha_elf_reloc_entry *reloc_entries;
187 /* Alpha ELF linker hash table. */
189 struct alpha_elf_link_hash_table
191 struct elf_link_hash_table root;
193 /* The head of a list of .got subsections linked through
194 alpha_elf_tdata(abfd)->got_link_next. */
197 /* The most recent relax pass that we've seen. The GOTs
198 should be regenerated if this doesn't match. */
202 /* Look up an entry in a Alpha ELF linker hash table. */
204 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
205 ((struct alpha_elf_link_hash_entry *) \
206 elf_link_hash_lookup (&(table)->root, (string), (create), \
209 /* Traverse a Alpha ELF linker hash table. */
211 #define alpha_elf_link_hash_traverse(table, func, info) \
212 (elf_link_hash_traverse \
214 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
217 /* Get the Alpha ELF linker hash table from a link_info structure. */
219 #define alpha_elf_hash_table(p) \
220 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
221 == ALPHA_ELF_DATA ? ((struct alpha_elf_link_hash_table *) ((p)->hash)) : NULL)
223 /* Get the object's symbols as our own entry type. */
225 #define alpha_elf_sym_hashes(abfd) \
226 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
228 /* Should we do dynamic things to this symbol? This differs from the
229 generic version in that we never need to consider function pointer
230 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
231 address is ever taken. */
233 static inline bfd_boolean
234 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
235 struct bfd_link_info *info)
237 return _bfd_elf_dynamic_symbol_p (h, info, 0);
240 /* Create an entry in a Alpha ELF linker hash table. */
242 static struct bfd_hash_entry *
243 elf64_alpha_link_hash_newfunc (struct bfd_hash_entry *entry,
244 struct bfd_hash_table *table,
247 struct alpha_elf_link_hash_entry *ret =
248 (struct alpha_elf_link_hash_entry *) entry;
250 /* Allocate the structure if it has not already been allocated by a
252 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
253 ret = ((struct alpha_elf_link_hash_entry *)
254 bfd_hash_allocate (table,
255 sizeof (struct alpha_elf_link_hash_entry)));
256 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
257 return (struct bfd_hash_entry *) ret;
259 /* Call the allocation method of the superclass. */
260 ret = ((struct alpha_elf_link_hash_entry *)
261 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
263 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
265 /* Set local fields. */
266 memset (&ret->esym, 0, sizeof (EXTR));
267 /* We use -2 as a marker to indicate that the information has
268 not been set. -1 means there is no associated ifd. */
271 ret->got_entries = NULL;
272 ret->reloc_entries = NULL;
275 return (struct bfd_hash_entry *) ret;
278 /* Create a Alpha ELF linker hash table. */
280 static struct bfd_link_hash_table *
281 elf64_alpha_bfd_link_hash_table_create (bfd *abfd)
283 struct alpha_elf_link_hash_table *ret;
284 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
286 ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
287 if (ret == (struct alpha_elf_link_hash_table *) NULL)
290 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
291 elf64_alpha_link_hash_newfunc,
292 sizeof (struct alpha_elf_link_hash_entry),
299 return &ret->root.root;
302 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
303 routine in order to handle the ECOFF debugging information. */
305 struct alpha_elf_find_line
307 struct ecoff_debug_info d;
308 struct ecoff_find_line i;
311 /* We have some private fields hanging off of the elf_tdata structure. */
313 struct alpha_elf_obj_tdata
315 struct elf_obj_tdata root;
317 /* For every input file, these are the got entries for that object's
319 struct alpha_elf_got_entry ** local_got_entries;
321 /* For every input file, this is the object that owns the got that
322 this input file uses. */
325 /* For every got, this is a linked list through the objects using this got */
326 bfd *in_got_link_next;
328 /* For every got, this is a link to the next got subsegment. */
331 /* For every got, this is the section. */
334 /* For every got, this is it's total number of words. */
337 /* For every got, this is the sum of the number of words required
338 to hold all of the member object's local got. */
341 /* Used by elf64_alpha_find_nearest_line entry point. */
342 struct alpha_elf_find_line *find_line_info;
346 #define alpha_elf_tdata(abfd) \
347 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
349 #define is_alpha_elf(bfd) \
350 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
351 && elf_tdata (bfd) != NULL \
352 && elf_object_id (bfd) == ALPHA_ELF_DATA)
355 elf64_alpha_mkobject (bfd *abfd)
357 return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
362 elf64_alpha_object_p (bfd *abfd)
364 /* Set the right machine number for an Alpha ELF file. */
365 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
368 /* A relocation function which doesn't do anything. */
370 static bfd_reloc_status_type
371 elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
372 asymbol *sym ATTRIBUTE_UNUSED,
373 void * data ATTRIBUTE_UNUSED, asection *sec,
374 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
377 reloc->address += sec->output_offset;
381 /* A relocation function used for an unsupported reloc. */
383 static bfd_reloc_status_type
384 elf64_alpha_reloc_bad (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
385 asymbol *sym ATTRIBUTE_UNUSED,
386 void * data ATTRIBUTE_UNUSED, asection *sec,
387 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
390 reloc->address += sec->output_offset;
391 return bfd_reloc_notsupported;
394 /* Do the work of the GPDISP relocation. */
396 static bfd_reloc_status_type
397 elf64_alpha_do_reloc_gpdisp (bfd *abfd, bfd_vma gpdisp, bfd_byte *p_ldah,
400 bfd_reloc_status_type ret = bfd_reloc_ok;
402 unsigned long i_ldah, i_lda;
404 i_ldah = bfd_get_32 (abfd, p_ldah);
405 i_lda = bfd_get_32 (abfd, p_lda);
407 /* Complain if the instructions are not correct. */
408 if (((i_ldah >> 26) & 0x3f) != 0x09
409 || ((i_lda >> 26) & 0x3f) != 0x08)
410 ret = bfd_reloc_dangerous;
412 /* Extract the user-supplied offset, mirroring the sign extensions
413 that the instructions perform. */
414 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
415 addend = (addend ^ 0x80008000) - 0x80008000;
419 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
420 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
421 ret = bfd_reloc_overflow;
423 /* compensate for the sign extension again. */
424 i_ldah = ((i_ldah & 0xffff0000)
425 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
426 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
428 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
429 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
434 /* The special function for the GPDISP reloc. */
436 static bfd_reloc_status_type
437 elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry,
438 asymbol *sym ATTRIBUTE_UNUSED, void * data,
439 asection *input_section, bfd *output_bfd,
442 bfd_reloc_status_type ret;
443 bfd_vma gp, relocation;
444 bfd_vma high_address;
445 bfd_byte *p_ldah, *p_lda;
447 /* Don't do anything if we're not doing a final link. */
450 reloc_entry->address += input_section->output_offset;
454 high_address = bfd_get_section_limit (abfd, input_section);
455 if (reloc_entry->address > high_address
456 || reloc_entry->address + reloc_entry->addend > high_address)
457 return bfd_reloc_outofrange;
459 /* The gp used in the portion of the output object to which this
460 input object belongs is cached on the input bfd. */
461 gp = _bfd_get_gp_value (abfd);
463 relocation = (input_section->output_section->vma
464 + input_section->output_offset
465 + reloc_entry->address);
467 p_ldah = (bfd_byte *) data + reloc_entry->address;
468 p_lda = p_ldah + reloc_entry->addend;
470 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
472 /* Complain if the instructions are not correct. */
473 if (ret == bfd_reloc_dangerous)
474 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
479 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
480 from smaller values. Start with zero, widen, *then* decrement. */
481 #define MINUS_ONE (((bfd_vma)0) - 1)
484 #define SKIP_HOWTO(N) \
485 HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
487 static reloc_howto_type elf64_alpha_howto_table[] =
489 HOWTO (R_ALPHA_NONE, /* type */
491 0, /* size (0 = byte, 1 = short, 2 = long) */
493 TRUE, /* pc_relative */
495 complain_overflow_dont, /* complain_on_overflow */
496 elf64_alpha_reloc_nil, /* special_function */
498 FALSE, /* partial_inplace */
501 TRUE), /* pcrel_offset */
503 /* A 32 bit reference to a symbol. */
504 HOWTO (R_ALPHA_REFLONG, /* type */
506 2, /* size (0 = byte, 1 = short, 2 = long) */
508 FALSE, /* pc_relative */
510 complain_overflow_bitfield, /* complain_on_overflow */
511 bfd_elf_generic_reloc, /* special_function */
512 "REFLONG", /* name */
513 FALSE, /* partial_inplace */
514 0xffffffff, /* src_mask */
515 0xffffffff, /* dst_mask */
516 FALSE), /* pcrel_offset */
518 /* A 64 bit reference to a symbol. */
519 HOWTO (R_ALPHA_REFQUAD, /* type */
521 4, /* size (0 = byte, 1 = short, 2 = long) */
523 FALSE, /* pc_relative */
525 complain_overflow_bitfield, /* complain_on_overflow */
526 bfd_elf_generic_reloc, /* special_function */
527 "REFQUAD", /* name */
528 FALSE, /* partial_inplace */
529 MINUS_ONE, /* src_mask */
530 MINUS_ONE, /* dst_mask */
531 FALSE), /* pcrel_offset */
533 /* A 32 bit GP relative offset. This is just like REFLONG except
534 that when the value is used the value of the gp register will be
536 HOWTO (R_ALPHA_GPREL32, /* type */
538 2, /* size (0 = byte, 1 = short, 2 = long) */
540 FALSE, /* pc_relative */
542 complain_overflow_bitfield, /* complain_on_overflow */
543 bfd_elf_generic_reloc, /* special_function */
544 "GPREL32", /* name */
545 FALSE, /* partial_inplace */
546 0xffffffff, /* src_mask */
547 0xffffffff, /* dst_mask */
548 FALSE), /* pcrel_offset */
550 /* Used for an instruction that refers to memory off the GP register. */
551 HOWTO (R_ALPHA_LITERAL, /* type */
553 1, /* size (0 = byte, 1 = short, 2 = long) */
555 FALSE, /* pc_relative */
557 complain_overflow_signed, /* complain_on_overflow */
558 bfd_elf_generic_reloc, /* special_function */
559 "ELF_LITERAL", /* name */
560 FALSE, /* partial_inplace */
561 0xffff, /* src_mask */
562 0xffff, /* dst_mask */
563 FALSE), /* pcrel_offset */
565 /* This reloc only appears immediately following an ELF_LITERAL reloc.
566 It identifies a use of the literal. The symbol index is special:
567 1 means the literal address is in the base register of a memory
568 format instruction; 2 means the literal address is in the byte
569 offset register of a byte-manipulation instruction; 3 means the
570 literal address is in the target register of a jsr instruction.
571 This does not actually do any relocation. */
572 HOWTO (R_ALPHA_LITUSE, /* type */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
576 FALSE, /* pc_relative */
578 complain_overflow_dont, /* complain_on_overflow */
579 elf64_alpha_reloc_nil, /* special_function */
581 FALSE, /* partial_inplace */
584 FALSE), /* pcrel_offset */
586 /* Load the gp register. This is always used for a ldah instruction
587 which loads the upper 16 bits of the gp register. The symbol
588 index of the GPDISP instruction is an offset in bytes to the lda
589 instruction that loads the lower 16 bits. The value to use for
590 the relocation is the difference between the GP value and the
591 current location; the load will always be done against a register
592 holding the current address.
594 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
595 any offset is present in the instructions, it is an offset from
596 the register to the ldah instruction. This lets us avoid any
597 stupid hackery like inventing a gp value to do partial relocation
598 against. Also unlike ECOFF, we do the whole relocation off of
599 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
600 space consuming bit, that, since all the information was present
601 in the GPDISP_HI16 reloc. */
602 HOWTO (R_ALPHA_GPDISP, /* type */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
606 FALSE, /* pc_relative */
608 complain_overflow_dont, /* complain_on_overflow */
609 elf64_alpha_reloc_gpdisp, /* special_function */
611 FALSE, /* partial_inplace */
612 0xffff, /* src_mask */
613 0xffff, /* dst_mask */
614 TRUE), /* pcrel_offset */
616 /* A 21 bit branch. */
617 HOWTO (R_ALPHA_BRADDR, /* type */
619 2, /* size (0 = byte, 1 = short, 2 = long) */
621 TRUE, /* pc_relative */
623 complain_overflow_signed, /* complain_on_overflow */
624 bfd_elf_generic_reloc, /* special_function */
626 FALSE, /* partial_inplace */
627 0x1fffff, /* src_mask */
628 0x1fffff, /* dst_mask */
629 TRUE), /* pcrel_offset */
631 /* A hint for a jump to a register. */
632 HOWTO (R_ALPHA_HINT, /* type */
634 1, /* size (0 = byte, 1 = short, 2 = long) */
636 TRUE, /* pc_relative */
638 complain_overflow_dont, /* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
641 FALSE, /* partial_inplace */
642 0x3fff, /* src_mask */
643 0x3fff, /* dst_mask */
644 TRUE), /* pcrel_offset */
646 /* 16 bit PC relative offset. */
647 HOWTO (R_ALPHA_SREL16, /* type */
649 1, /* size (0 = byte, 1 = short, 2 = long) */
651 TRUE, /* pc_relative */
653 complain_overflow_signed, /* complain_on_overflow */
654 bfd_elf_generic_reloc, /* special_function */
656 FALSE, /* partial_inplace */
657 0xffff, /* src_mask */
658 0xffff, /* dst_mask */
659 TRUE), /* pcrel_offset */
661 /* 32 bit PC relative offset. */
662 HOWTO (R_ALPHA_SREL32, /* type */
664 2, /* size (0 = byte, 1 = short, 2 = long) */
666 TRUE, /* pc_relative */
668 complain_overflow_signed, /* complain_on_overflow */
669 bfd_elf_generic_reloc, /* special_function */
671 FALSE, /* partial_inplace */
672 0xffffffff, /* src_mask */
673 0xffffffff, /* dst_mask */
674 TRUE), /* pcrel_offset */
676 /* A 64 bit PC relative offset. */
677 HOWTO (R_ALPHA_SREL64, /* type */
679 4, /* size (0 = byte, 1 = short, 2 = long) */
681 TRUE, /* pc_relative */
683 complain_overflow_signed, /* complain_on_overflow */
684 bfd_elf_generic_reloc, /* special_function */
686 FALSE, /* partial_inplace */
687 MINUS_ONE, /* src_mask */
688 MINUS_ONE, /* dst_mask */
689 TRUE), /* pcrel_offset */
691 /* Skip 12 - 16; deprecated ECOFF relocs. */
698 /* The high 16 bits of the displacement from GP to the target. */
699 HOWTO (R_ALPHA_GPRELHIGH,
701 1, /* size (0 = byte, 1 = short, 2 = long) */
703 FALSE, /* pc_relative */
705 complain_overflow_signed, /* complain_on_overflow */
706 bfd_elf_generic_reloc, /* special_function */
707 "GPRELHIGH", /* name */
708 FALSE, /* partial_inplace */
709 0xffff, /* src_mask */
710 0xffff, /* dst_mask */
711 FALSE), /* pcrel_offset */
713 /* The low 16 bits of the displacement from GP to the target. */
714 HOWTO (R_ALPHA_GPRELLOW,
716 1, /* size (0 = byte, 1 = short, 2 = long) */
718 FALSE, /* pc_relative */
720 complain_overflow_dont, /* complain_on_overflow */
721 bfd_elf_generic_reloc, /* special_function */
722 "GPRELLOW", /* name */
723 FALSE, /* partial_inplace */
724 0xffff, /* src_mask */
725 0xffff, /* dst_mask */
726 FALSE), /* pcrel_offset */
728 /* A 16-bit displacement from the GP to the target. */
729 HOWTO (R_ALPHA_GPREL16,
731 1, /* size (0 = byte, 1 = short, 2 = long) */
733 FALSE, /* pc_relative */
735 complain_overflow_signed, /* complain_on_overflow */
736 bfd_elf_generic_reloc, /* special_function */
737 "GPREL16", /* name */
738 FALSE, /* partial_inplace */
739 0xffff, /* src_mask */
740 0xffff, /* dst_mask */
741 FALSE), /* pcrel_offset */
743 /* Skip 20 - 23; deprecated ECOFF relocs. */
749 /* Misc ELF relocations. */
751 /* A dynamic relocation to copy the target into our .dynbss section. */
752 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
753 is present because every other ELF has one, but should not be used
754 because .dynbss is an ugly thing. */
761 complain_overflow_dont,
762 bfd_elf_generic_reloc,
769 /* A dynamic relocation for a .got entry. */
770 HOWTO (R_ALPHA_GLOB_DAT,
776 complain_overflow_dont,
777 bfd_elf_generic_reloc,
784 /* A dynamic relocation for a .plt entry. */
785 HOWTO (R_ALPHA_JMP_SLOT,
791 complain_overflow_dont,
792 bfd_elf_generic_reloc,
799 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
800 HOWTO (R_ALPHA_RELATIVE,
806 complain_overflow_dont,
807 bfd_elf_generic_reloc,
814 /* A 21 bit branch that adjusts for gp loads. */
815 HOWTO (R_ALPHA_BRSGP, /* type */
817 2, /* size (0 = byte, 1 = short, 2 = long) */
819 TRUE, /* pc_relative */
821 complain_overflow_signed, /* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
824 FALSE, /* partial_inplace */
825 0x1fffff, /* src_mask */
826 0x1fffff, /* dst_mask */
827 TRUE), /* pcrel_offset */
829 /* Creates a tls_index for the symbol in the got. */
830 HOWTO (R_ALPHA_TLSGD, /* type */
832 1, /* size (0 = byte, 1 = short, 2 = long) */
834 FALSE, /* pc_relative */
836 complain_overflow_signed, /* complain_on_overflow */
837 bfd_elf_generic_reloc, /* special_function */
839 FALSE, /* partial_inplace */
840 0xffff, /* src_mask */
841 0xffff, /* dst_mask */
842 FALSE), /* pcrel_offset */
844 /* Creates a tls_index for the (current) module in the got. */
845 HOWTO (R_ALPHA_TLSLDM, /* type */
847 1, /* size (0 = byte, 1 = short, 2 = long) */
849 FALSE, /* pc_relative */
851 complain_overflow_signed, /* complain_on_overflow */
852 bfd_elf_generic_reloc, /* special_function */
854 FALSE, /* partial_inplace */
855 0xffff, /* src_mask */
856 0xffff, /* dst_mask */
857 FALSE), /* pcrel_offset */
859 /* A dynamic relocation for a DTP module entry. */
860 HOWTO (R_ALPHA_DTPMOD64, /* type */
862 4, /* size (0 = byte, 1 = short, 2 = long) */
864 FALSE, /* pc_relative */
866 complain_overflow_bitfield, /* complain_on_overflow */
867 bfd_elf_generic_reloc, /* special_function */
868 "DTPMOD64", /* name */
869 FALSE, /* partial_inplace */
870 MINUS_ONE, /* src_mask */
871 MINUS_ONE, /* dst_mask */
872 FALSE), /* pcrel_offset */
874 /* Creates a 64-bit offset in the got for the displacement
875 from DTP to the target. */
876 HOWTO (R_ALPHA_GOTDTPREL, /* type */
878 1, /* size (0 = byte, 1 = short, 2 = long) */
880 FALSE, /* pc_relative */
882 complain_overflow_signed, /* complain_on_overflow */
883 bfd_elf_generic_reloc, /* special_function */
884 "GOTDTPREL", /* name */
885 FALSE, /* partial_inplace */
886 0xffff, /* src_mask */
887 0xffff, /* dst_mask */
888 FALSE), /* pcrel_offset */
890 /* A dynamic relocation for a displacement from DTP to the target. */
891 HOWTO (R_ALPHA_DTPREL64, /* type */
893 4, /* size (0 = byte, 1 = short, 2 = long) */
895 FALSE, /* pc_relative */
897 complain_overflow_bitfield, /* complain_on_overflow */
898 bfd_elf_generic_reloc, /* special_function */
899 "DTPREL64", /* name */
900 FALSE, /* partial_inplace */
901 MINUS_ONE, /* src_mask */
902 MINUS_ONE, /* dst_mask */
903 FALSE), /* pcrel_offset */
905 /* The high 16 bits of the displacement from DTP to the target. */
906 HOWTO (R_ALPHA_DTPRELHI, /* type */
908 1, /* size (0 = byte, 1 = short, 2 = long) */
910 FALSE, /* pc_relative */
912 complain_overflow_signed, /* complain_on_overflow */
913 bfd_elf_generic_reloc, /* special_function */
914 "DTPRELHI", /* name */
915 FALSE, /* partial_inplace */
916 0xffff, /* src_mask */
917 0xffff, /* dst_mask */
918 FALSE), /* pcrel_offset */
920 /* The low 16 bits of the displacement from DTP to the target. */
921 HOWTO (R_ALPHA_DTPRELLO, /* type */
923 1, /* size (0 = byte, 1 = short, 2 = long) */
925 FALSE, /* pc_relative */
927 complain_overflow_dont, /* complain_on_overflow */
928 bfd_elf_generic_reloc, /* special_function */
929 "DTPRELLO", /* name */
930 FALSE, /* partial_inplace */
931 0xffff, /* src_mask */
932 0xffff, /* dst_mask */
933 FALSE), /* pcrel_offset */
935 /* A 16-bit displacement from DTP to the target. */
936 HOWTO (R_ALPHA_DTPREL16, /* type */
938 1, /* size (0 = byte, 1 = short, 2 = long) */
940 FALSE, /* pc_relative */
942 complain_overflow_signed, /* complain_on_overflow */
943 bfd_elf_generic_reloc, /* special_function */
944 "DTPREL16", /* name */
945 FALSE, /* partial_inplace */
946 0xffff, /* src_mask */
947 0xffff, /* dst_mask */
948 FALSE), /* pcrel_offset */
950 /* Creates a 64-bit offset in the got for the displacement
951 from TP to the target. */
952 HOWTO (R_ALPHA_GOTTPREL, /* type */
954 1, /* size (0 = byte, 1 = short, 2 = long) */
956 FALSE, /* pc_relative */
958 complain_overflow_signed, /* complain_on_overflow */
959 bfd_elf_generic_reloc, /* special_function */
960 "GOTTPREL", /* name */
961 FALSE, /* partial_inplace */
962 0xffff, /* src_mask */
963 0xffff, /* dst_mask */
964 FALSE), /* pcrel_offset */
966 /* A dynamic relocation for a displacement from TP to the target. */
967 HOWTO (R_ALPHA_TPREL64, /* type */
969 4, /* size (0 = byte, 1 = short, 2 = long) */
971 FALSE, /* pc_relative */
973 complain_overflow_bitfield, /* complain_on_overflow */
974 bfd_elf_generic_reloc, /* special_function */
975 "TPREL64", /* name */
976 FALSE, /* partial_inplace */
977 MINUS_ONE, /* src_mask */
978 MINUS_ONE, /* dst_mask */
979 FALSE), /* pcrel_offset */
981 /* The high 16 bits of the displacement from TP to the target. */
982 HOWTO (R_ALPHA_TPRELHI, /* type */
984 1, /* size (0 = byte, 1 = short, 2 = long) */
986 FALSE, /* pc_relative */
988 complain_overflow_signed, /* complain_on_overflow */
989 bfd_elf_generic_reloc, /* special_function */
990 "TPRELHI", /* name */
991 FALSE, /* partial_inplace */
992 0xffff, /* src_mask */
993 0xffff, /* dst_mask */
994 FALSE), /* pcrel_offset */
996 /* The low 16 bits of the displacement from TP to the target. */
997 HOWTO (R_ALPHA_TPRELLO, /* type */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 FALSE, /* pc_relative */
1003 complain_overflow_dont, /* complain_on_overflow */
1004 bfd_elf_generic_reloc, /* special_function */
1005 "TPRELLO", /* name */
1006 FALSE, /* partial_inplace */
1007 0xffff, /* src_mask */
1008 0xffff, /* dst_mask */
1009 FALSE), /* pcrel_offset */
1011 /* A 16-bit displacement from TP to the target. */
1012 HOWTO (R_ALPHA_TPREL16, /* type */
1014 1, /* size (0 = byte, 1 = short, 2 = long) */
1016 FALSE, /* pc_relative */
1018 complain_overflow_signed, /* complain_on_overflow */
1019 bfd_elf_generic_reloc, /* special_function */
1020 "TPREL16", /* name */
1021 FALSE, /* partial_inplace */
1022 0xffff, /* src_mask */
1023 0xffff, /* dst_mask */
1024 FALSE), /* pcrel_offset */
1027 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1029 struct elf_reloc_map
1031 bfd_reloc_code_real_type bfd_reloc_val;
1035 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1037 {BFD_RELOC_NONE, R_ALPHA_NONE},
1038 {BFD_RELOC_32, R_ALPHA_REFLONG},
1039 {BFD_RELOC_64, R_ALPHA_REFQUAD},
1040 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
1041 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
1042 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
1043 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
1044 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
1045 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
1046 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
1047 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
1048 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
1049 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
1050 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
1051 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
1052 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
1053 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
1054 {BFD_RELOC_ALPHA_TLSGD, R_ALPHA_TLSGD},
1055 {BFD_RELOC_ALPHA_TLSLDM, R_ALPHA_TLSLDM},
1056 {BFD_RELOC_ALPHA_DTPMOD64, R_ALPHA_DTPMOD64},
1057 {BFD_RELOC_ALPHA_GOTDTPREL16, R_ALPHA_GOTDTPREL},
1058 {BFD_RELOC_ALPHA_DTPREL64, R_ALPHA_DTPREL64},
1059 {BFD_RELOC_ALPHA_DTPREL_HI16, R_ALPHA_DTPRELHI},
1060 {BFD_RELOC_ALPHA_DTPREL_LO16, R_ALPHA_DTPRELLO},
1061 {BFD_RELOC_ALPHA_DTPREL16, R_ALPHA_DTPREL16},
1062 {BFD_RELOC_ALPHA_GOTTPREL16, R_ALPHA_GOTTPREL},
1063 {BFD_RELOC_ALPHA_TPREL64, R_ALPHA_TPREL64},
1064 {BFD_RELOC_ALPHA_TPREL_HI16, R_ALPHA_TPRELHI},
1065 {BFD_RELOC_ALPHA_TPREL_LO16, R_ALPHA_TPRELLO},
1066 {BFD_RELOC_ALPHA_TPREL16, R_ALPHA_TPREL16},
1069 /* Given a BFD reloc type, return a HOWTO structure. */
1071 static reloc_howto_type *
1072 elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1073 bfd_reloc_code_real_type code)
1075 const struct elf_reloc_map *i, *e;
1076 i = e = elf64_alpha_reloc_map;
1077 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1080 if (i->bfd_reloc_val == code)
1081 return &elf64_alpha_howto_table[i->elf_reloc_val];
1086 static reloc_howto_type *
1087 elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1093 i < (sizeof (elf64_alpha_howto_table)
1094 / sizeof (elf64_alpha_howto_table[0]));
1096 if (elf64_alpha_howto_table[i].name != NULL
1097 && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0)
1098 return &elf64_alpha_howto_table[i];
1103 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1106 elf64_alpha_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1107 Elf_Internal_Rela *dst)
1109 unsigned r_type = ELF64_R_TYPE(dst->r_info);
1110 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
1111 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1114 /* These two relocations create a two-word entry in the got. */
1115 #define alpha_got_entry_size(r_type) \
1116 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1118 /* This is PT_TLS segment p_vaddr. */
1119 #define alpha_get_dtprel_base(info) \
1120 (elf_hash_table (info)->tls_sec->vma)
1122 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1123 is assigned offset round(16, PT_TLS p_align). */
1124 #define alpha_get_tprel_base(info) \
1125 (elf_hash_table (info)->tls_sec->vma \
1126 - align_power ((bfd_vma) 16, \
1127 elf_hash_table (info)->tls_sec->alignment_power))
1129 /* Handle an Alpha specific section when reading an object file. This
1130 is called when bfd_section_from_shdr finds a section with an unknown
1132 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1136 elf64_alpha_section_from_shdr (bfd *abfd,
1137 Elf_Internal_Shdr *hdr,
1143 /* There ought to be a place to keep ELF backend specific flags, but
1144 at the moment there isn't one. We just keep track of the
1145 sections by their name, instead. Fortunately, the ABI gives
1146 suggested names for all the MIPS specific sections, so we will
1147 probably get away with this. */
1148 switch (hdr->sh_type)
1150 case SHT_ALPHA_DEBUG:
1151 if (strcmp (name, ".mdebug") != 0)
1158 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1160 newsect = hdr->bfd_section;
1162 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1164 if (! bfd_set_section_flags (abfd, newsect,
1165 (bfd_get_section_flags (abfd, newsect)
1173 /* Convert Alpha specific section flags to bfd internal section flags. */
1176 elf64_alpha_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
1178 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1179 *flags |= SEC_SMALL_DATA;
1184 /* Set the correct type for an Alpha ELF section. We do this by the
1185 section name, which is a hack, but ought to work. */
1188 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1190 register const char *name;
1192 name = bfd_get_section_name (abfd, sec);
1194 if (strcmp (name, ".mdebug") == 0)
1196 hdr->sh_type = SHT_ALPHA_DEBUG;
1197 /* In a shared object on Irix 5.3, the .mdebug section has an
1198 entsize of 0. FIXME: Does this matter? */
1199 if ((abfd->flags & DYNAMIC) != 0 )
1200 hdr->sh_entsize = 0;
1202 hdr->sh_entsize = 1;
1204 else if ((sec->flags & SEC_SMALL_DATA)
1205 || strcmp (name, ".sdata") == 0
1206 || strcmp (name, ".sbss") == 0
1207 || strcmp (name, ".lit4") == 0
1208 || strcmp (name, ".lit8") == 0)
1209 hdr->sh_flags |= SHF_ALPHA_GPREL;
1214 /* Hook called by the linker routine which adds symbols from an object
1215 file. We use it to put .comm items in .sbss, and not .bss. */
1218 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1219 Elf_Internal_Sym *sym,
1220 const char **namep ATTRIBUTE_UNUSED,
1221 flagword *flagsp ATTRIBUTE_UNUSED,
1222 asection **secp, bfd_vma *valp)
1224 if (sym->st_shndx == SHN_COMMON
1225 && !info->relocatable
1226 && sym->st_size <= elf_gp_size (abfd))
1228 /* Common symbols less than or equal to -G nn bytes are
1229 automatically put into .sbss. */
1231 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1235 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1238 | SEC_LINKER_CREATED));
1244 *valp = sym->st_size;
1250 /* Create the .got section. */
1253 elf64_alpha_create_got_section (bfd *abfd,
1254 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1259 if (! is_alpha_elf (abfd))
1262 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1263 | SEC_LINKER_CREATED);
1264 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1266 || !bfd_set_section_alignment (abfd, s, 3))
1269 alpha_elf_tdata (abfd)->got = s;
1271 /* Make sure the object's gotobj is set to itself so that we default
1272 to every object with its own .got. We'll merge .gots later once
1273 we've collected each object's info. */
1274 alpha_elf_tdata (abfd)->gotobj = abfd;
1279 /* Create all the dynamic sections. */
1282 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1286 struct elf_link_hash_entry *h;
1288 if (! is_alpha_elf (abfd))
1291 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1293 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1294 | SEC_LINKER_CREATED
1295 | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1296 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1297 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4))
1300 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1302 h = _bfd_elf_define_linkage_sym (abfd, info, s,
1303 "_PROCEDURE_LINKAGE_TABLE_");
1304 elf_hash_table (info)->hplt = h;
1308 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1309 | SEC_LINKER_CREATED | SEC_READONLY);
1310 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1311 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1314 if (elf64_alpha_use_secureplt)
1316 flags = SEC_ALLOC | SEC_LINKER_CREATED;
1317 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1318 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1322 /* We may or may not have created a .got section for this object, but
1323 we definitely havn't done the rest of the work. */
1325 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1327 if (!elf64_alpha_create_got_section (abfd, info))
1331 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1332 | SEC_LINKER_CREATED | SEC_READONLY);
1333 s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1335 || !bfd_set_section_alignment (abfd, s, 3))
1338 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1339 dynobj's .got section. We don't do this in the linker script
1340 because we don't want to define the symbol if we are not creating
1341 a global offset table. */
1342 h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1343 "_GLOBAL_OFFSET_TABLE_");
1344 elf_hash_table (info)->hgot = h;
1351 /* Read ECOFF debugging information from a .mdebug section into a
1352 ecoff_debug_info structure. */
1355 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1356 struct ecoff_debug_info *debug)
1359 const struct ecoff_debug_swap *swap;
1360 char *ext_hdr = NULL;
1362 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1363 memset (debug, 0, sizeof (*debug));
1365 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1366 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1369 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1370 swap->external_hdr_size))
1373 symhdr = &debug->symbolic_header;
1374 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1376 /* The symbolic header contains absolute file offsets and sizes to
1378 #define READ(ptr, offset, count, size, type) \
1379 if (symhdr->count == 0) \
1380 debug->ptr = NULL; \
1383 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1384 debug->ptr = (type) bfd_malloc (amt); \
1385 if (debug->ptr == NULL) \
1386 goto error_return; \
1387 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1388 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1389 goto error_return; \
1392 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1393 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1394 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1395 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1396 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1397 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1399 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1400 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1401 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1402 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1403 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1411 if (ext_hdr != NULL)
1413 if (debug->line != NULL)
1415 if (debug->external_dnr != NULL)
1416 free (debug->external_dnr);
1417 if (debug->external_pdr != NULL)
1418 free (debug->external_pdr);
1419 if (debug->external_sym != NULL)
1420 free (debug->external_sym);
1421 if (debug->external_opt != NULL)
1422 free (debug->external_opt);
1423 if (debug->external_aux != NULL)
1424 free (debug->external_aux);
1425 if (debug->ss != NULL)
1427 if (debug->ssext != NULL)
1428 free (debug->ssext);
1429 if (debug->external_fdr != NULL)
1430 free (debug->external_fdr);
1431 if (debug->external_rfd != NULL)
1432 free (debug->external_rfd);
1433 if (debug->external_ext != NULL)
1434 free (debug->external_ext);
1438 /* Alpha ELF local labels start with '$'. */
1441 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1443 return name[0] == '$';
1447 elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols,
1448 bfd_vma offset, const char **filename_ptr,
1449 const char **functionname_ptr,
1450 unsigned int *line_ptr)
1454 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
1455 section, symbols, offset,
1456 filename_ptr, functionname_ptr,
1458 &elf_tdata (abfd)->dwarf2_find_line_info))
1461 msec = bfd_get_section_by_name (abfd, ".mdebug");
1465 struct alpha_elf_find_line *fi;
1466 const struct ecoff_debug_swap * const swap =
1467 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1469 /* If we are called during a link, alpha_elf_final_link may have
1470 cleared the SEC_HAS_CONTENTS field. We force it back on here
1471 if appropriate (which it normally will be). */
1472 origflags = msec->flags;
1473 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1474 msec->flags |= SEC_HAS_CONTENTS;
1476 fi = alpha_elf_tdata (abfd)->find_line_info;
1479 bfd_size_type external_fdr_size;
1482 struct fdr *fdr_ptr;
1483 bfd_size_type amt = sizeof (struct alpha_elf_find_line);
1485 fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt);
1488 msec->flags = origflags;
1492 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1494 msec->flags = origflags;
1498 /* Swap in the FDR information. */
1499 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1500 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1501 if (fi->d.fdr == NULL)
1503 msec->flags = origflags;
1506 external_fdr_size = swap->external_fdr_size;
1507 fdr_ptr = fi->d.fdr;
1508 fraw_src = (char *) fi->d.external_fdr;
1509 fraw_end = (fraw_src
1510 + fi->d.symbolic_header.ifdMax * external_fdr_size);
1511 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1512 (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
1514 alpha_elf_tdata (abfd)->find_line_info = fi;
1516 /* Note that we don't bother to ever free this information.
1517 find_nearest_line is either called all the time, as in
1518 objdump -l, so the information should be saved, or it is
1519 rarely called, as in ld error messages, so the memory
1520 wasted is unimportant. Still, it would probably be a
1521 good idea for free_cached_info to throw it away. */
1524 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1525 &fi->i, filename_ptr, functionname_ptr,
1528 msec->flags = origflags;
1532 msec->flags = origflags;
1535 /* Fall back on the generic ELF find_nearest_line routine. */
1537 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
1538 filename_ptr, functionname_ptr,
1542 /* Structure used to pass information to alpha_elf_output_extsym. */
1547 struct bfd_link_info *info;
1548 struct ecoff_debug_info *debug;
1549 const struct ecoff_debug_swap *swap;
1554 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
1556 struct extsym_info *einfo = (struct extsym_info *) data;
1558 asection *sec, *output_section;
1560 if (h->root.indx == -2)
1562 else if ((h->root.def_dynamic
1563 || h->root.ref_dynamic
1564 || h->root.root.type == bfd_link_hash_new)
1565 && !h->root.def_regular
1566 && !h->root.ref_regular)
1568 else if (einfo->info->strip == strip_all
1569 || (einfo->info->strip == strip_some
1570 && bfd_hash_lookup (einfo->info->keep_hash,
1571 h->root.root.root.string,
1572 FALSE, FALSE) == NULL))
1580 if (h->esym.ifd == -2)
1583 h->esym.cobol_main = 0;
1584 h->esym.weakext = 0;
1585 h->esym.reserved = 0;
1586 h->esym.ifd = ifdNil;
1587 h->esym.asym.value = 0;
1588 h->esym.asym.st = stGlobal;
1590 if (h->root.root.type != bfd_link_hash_defined
1591 && h->root.root.type != bfd_link_hash_defweak)
1592 h->esym.asym.sc = scAbs;
1597 sec = h->root.root.u.def.section;
1598 output_section = sec->output_section;
1600 /* When making a shared library and symbol h is the one from
1601 the another shared library, OUTPUT_SECTION may be null. */
1602 if (output_section == NULL)
1603 h->esym.asym.sc = scUndefined;
1606 name = bfd_section_name (output_section->owner, output_section);
1608 if (strcmp (name, ".text") == 0)
1609 h->esym.asym.sc = scText;
1610 else if (strcmp (name, ".data") == 0)
1611 h->esym.asym.sc = scData;
1612 else if (strcmp (name, ".sdata") == 0)
1613 h->esym.asym.sc = scSData;
1614 else if (strcmp (name, ".rodata") == 0
1615 || strcmp (name, ".rdata") == 0)
1616 h->esym.asym.sc = scRData;
1617 else if (strcmp (name, ".bss") == 0)
1618 h->esym.asym.sc = scBss;
1619 else if (strcmp (name, ".sbss") == 0)
1620 h->esym.asym.sc = scSBss;
1621 else if (strcmp (name, ".init") == 0)
1622 h->esym.asym.sc = scInit;
1623 else if (strcmp (name, ".fini") == 0)
1624 h->esym.asym.sc = scFini;
1626 h->esym.asym.sc = scAbs;
1630 h->esym.asym.reserved = 0;
1631 h->esym.asym.index = indexNil;
1634 if (h->root.root.type == bfd_link_hash_common)
1635 h->esym.asym.value = h->root.root.u.c.size;
1636 else if (h->root.root.type == bfd_link_hash_defined
1637 || h->root.root.type == bfd_link_hash_defweak)
1639 if (h->esym.asym.sc == scCommon)
1640 h->esym.asym.sc = scBss;
1641 else if (h->esym.asym.sc == scSCommon)
1642 h->esym.asym.sc = scSBss;
1644 sec = h->root.root.u.def.section;
1645 output_section = sec->output_section;
1646 if (output_section != NULL)
1647 h->esym.asym.value = (h->root.root.u.def.value
1648 + sec->output_offset
1649 + output_section->vma);
1651 h->esym.asym.value = 0;
1654 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1655 h->root.root.root.string,
1658 einfo->failed = TRUE;
1665 /* Search for and possibly create a got entry. */
1667 static struct alpha_elf_got_entry *
1668 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1669 unsigned long r_type, unsigned long r_symndx,
1672 struct alpha_elf_got_entry *gotent;
1673 struct alpha_elf_got_entry **slot;
1676 slot = &h->got_entries;
1679 /* This is a local .got entry -- record for merge. */
1681 struct alpha_elf_got_entry **local_got_entries;
1683 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1684 if (!local_got_entries)
1687 Elf_Internal_Shdr *symtab_hdr;
1689 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1690 size = symtab_hdr->sh_info;
1691 size *= sizeof (struct alpha_elf_got_entry *);
1694 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1695 if (!local_got_entries)
1698 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1701 slot = &local_got_entries[r_symndx];
1704 for (gotent = *slot; gotent ; gotent = gotent->next)
1705 if (gotent->gotobj == abfd
1706 && gotent->reloc_type == r_type
1707 && gotent->addend == r_addend)
1715 amt = sizeof (struct alpha_elf_got_entry);
1716 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1720 gotent->gotobj = abfd;
1721 gotent->addend = r_addend;
1722 gotent->got_offset = -1;
1723 gotent->plt_offset = -1;
1724 gotent->use_count = 1;
1725 gotent->reloc_type = r_type;
1726 gotent->reloc_done = 0;
1727 gotent->reloc_xlated = 0;
1729 gotent->next = *slot;
1732 entry_size = alpha_got_entry_size (r_type);
1733 alpha_elf_tdata (abfd)->total_got_size += entry_size;
1735 alpha_elf_tdata(abfd)->local_got_size += entry_size;
1738 gotent->use_count += 1;
1744 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1746 return ((ah->root.type == STT_FUNC
1747 || ah->root.root.type == bfd_link_hash_undefweak
1748 || ah->root.root.type == bfd_link_hash_undefined)
1749 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1750 && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1753 /* Handle dynamic relocations when doing an Alpha ELF link. */
1756 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1757 asection *sec, const Elf_Internal_Rela *relocs)
1761 Elf_Internal_Shdr *symtab_hdr;
1762 struct alpha_elf_link_hash_entry **sym_hashes;
1763 const Elf_Internal_Rela *rel, *relend;
1766 if (info->relocatable)
1769 /* Don't do anything special with non-loaded, non-alloced sections.
1770 In particular, any relocs in such sections should not affect GOT
1771 and PLT reference counting (ie. we don't allow them to create GOT
1772 or PLT entries), there's no possibility or desire to optimize TLS
1773 relocs, and there's not much point in propagating relocs to shared
1774 libs that the dynamic linker won't relocate. */
1775 if ((sec->flags & SEC_ALLOC) == 0)
1778 BFD_ASSERT (is_alpha_elf (abfd));
1780 dynobj = elf_hash_table (info)->dynobj;
1782 elf_hash_table (info)->dynobj = dynobj = abfd;
1785 symtab_hdr = &elf_symtab_hdr (abfd);
1786 sym_hashes = alpha_elf_sym_hashes (abfd);
1788 relend = relocs + sec->reloc_count;
1789 for (rel = relocs; rel < relend; ++rel)
1797 unsigned long r_symndx, r_type;
1798 struct alpha_elf_link_hash_entry *h;
1799 unsigned int gotent_flags;
1800 bfd_boolean maybe_dynamic;
1804 r_symndx = ELF64_R_SYM (rel->r_info);
1805 if (r_symndx < symtab_hdr->sh_info)
1809 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1811 while (h->root.root.type == bfd_link_hash_indirect
1812 || h->root.root.type == bfd_link_hash_warning)
1813 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1815 /* PR15323, ref flags aren't set for references in the same
1817 h->root.root.non_ir_ref = 1;
1818 h->root.ref_regular = 1;
1821 /* We can only get preliminary data on whether a symbol is
1822 locally or externally defined, as not all of the input files
1823 have yet been processed. Do something with what we know, as
1824 this may help reduce memory usage and processing time later. */
1825 maybe_dynamic = FALSE;
1826 if (h && ((info->shared
1828 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1829 || !h->root.def_regular
1830 || h->root.root.type == bfd_link_hash_defweak))
1831 maybe_dynamic = TRUE;
1835 r_type = ELF64_R_TYPE (rel->r_info);
1836 addend = rel->r_addend;
1840 case R_ALPHA_LITERAL:
1841 need = NEED_GOT | NEED_GOT_ENTRY;
1843 /* Remember how this literal is used from its LITUSEs.
1844 This will be important when it comes to decide if we can
1845 create a .plt entry for a function symbol. */
1846 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
1847 if (rel->r_addend >= 1 && rel->r_addend <= 6)
1848 gotent_flags |= 1 << rel->r_addend;
1851 /* No LITUSEs -- presumably the address is used somehow. */
1852 if (gotent_flags == 0)
1853 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
1856 case R_ALPHA_GPDISP:
1857 case R_ALPHA_GPREL16:
1858 case R_ALPHA_GPREL32:
1859 case R_ALPHA_GPRELHIGH:
1860 case R_ALPHA_GPRELLOW:
1865 case R_ALPHA_REFLONG:
1866 case R_ALPHA_REFQUAD:
1867 if (info->shared || maybe_dynamic)
1871 case R_ALPHA_TLSLDM:
1872 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1873 reloc to the STN_UNDEF (0) symbol so that they all match. */
1874 r_symndx = STN_UNDEF;
1876 maybe_dynamic = FALSE;
1880 case R_ALPHA_GOTDTPREL:
1881 need = NEED_GOT | NEED_GOT_ENTRY;
1884 case R_ALPHA_GOTTPREL:
1885 need = NEED_GOT | NEED_GOT_ENTRY;
1886 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
1888 info->flags |= DF_STATIC_TLS;
1891 case R_ALPHA_TPREL64:
1892 if (info->shared && !info->pie)
1894 info->flags |= DF_STATIC_TLS;
1897 else if (maybe_dynamic)
1902 if (need & NEED_GOT)
1904 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1906 if (!elf64_alpha_create_got_section (abfd, info))
1911 if (need & NEED_GOT_ENTRY)
1913 struct alpha_elf_got_entry *gotent;
1915 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
1921 gotent->flags |= gotent_flags;
1924 gotent_flags |= h->flags;
1925 h->flags = gotent_flags;
1927 /* Make a guess as to whether a .plt entry is needed. */
1928 /* ??? It appears that we won't make it into
1929 adjust_dynamic_symbol for symbols that remain
1930 totally undefined. Copying this check here means
1931 we can create a plt entry for them too. */
1933 = (maybe_dynamic && elf64_alpha_want_plt (h));
1938 if (need & NEED_DYNREL)
1940 /* We need to create the section here now whether we eventually
1941 use it or not so that it gets mapped to an output section by
1942 the linker. If not used, we'll kill it in size_dynamic_sections. */
1945 sreloc = _bfd_elf_make_dynamic_reloc_section
1946 (sec, dynobj, 3, abfd, /*rela?*/ TRUE);
1954 /* Since we havn't seen all of the input symbols yet, we
1955 don't know whether we'll actually need a dynamic relocation
1956 entry for this reloc. So make a record of it. Once we
1957 find out if this thing needs dynamic relocation we'll
1958 expand the relocation sections by the appropriate amount. */
1960 struct alpha_elf_reloc_entry *rent;
1962 for (rent = h->reloc_entries; rent; rent = rent->next)
1963 if (rent->rtype == r_type && rent->srel == sreloc)
1968 amt = sizeof (struct alpha_elf_reloc_entry);
1969 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
1973 rent->srel = sreloc;
1974 rent->rtype = r_type;
1976 rent->reltext = (sec->flags & SEC_READONLY) != 0;
1978 rent->next = h->reloc_entries;
1979 h->reloc_entries = rent;
1984 else if (info->shared)
1986 /* If this is a shared library, and the section is to be
1987 loaded into memory, we need a RELATIVE reloc. */
1988 sreloc->size += sizeof (Elf64_External_Rela);
1989 if (sec->flags & SEC_READONLY)
1990 info->flags |= DF_TEXTREL;
1998 /* Return the section that should be marked against GC for a given
2002 elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info,
2003 Elf_Internal_Rela *rel,
2004 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
2006 /* These relocations don't really reference a symbol. Instead we store
2007 extra data in their addend slot. Ignore the symbol. */
2008 switch (ELF64_R_TYPE (rel->r_info))
2010 case R_ALPHA_LITUSE:
2011 case R_ALPHA_GPDISP:
2016 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2019 /* Update the got entry reference counts for the section being removed. */
2022 elf64_alpha_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2023 asection *sec, const Elf_Internal_Rela *relocs)
2025 Elf_Internal_Shdr *symtab_hdr;
2026 struct alpha_elf_link_hash_entry **sym_hashes;
2027 const Elf_Internal_Rela *rel, *relend;
2029 if (info->relocatable)
2032 symtab_hdr = &elf_symtab_hdr (abfd);
2033 sym_hashes = alpha_elf_sym_hashes (abfd);
2035 relend = relocs + sec->reloc_count;
2036 for (rel = relocs; rel < relend; rel++)
2038 unsigned long r_symndx, r_type;
2039 struct alpha_elf_link_hash_entry *h = NULL;
2040 struct alpha_elf_got_entry *gotent;
2042 r_symndx = ELF64_R_SYM (rel->r_info);
2043 if (r_symndx >= symtab_hdr->sh_info)
2045 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2046 while (h->root.root.type == bfd_link_hash_indirect
2047 || h->root.root.type == bfd_link_hash_warning)
2048 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2051 r_type = ELF64_R_TYPE (rel->r_info);
2054 case R_ALPHA_LITERAL:
2055 /* ??? Ignore re-computation of gotent_flags. We're not
2056 carrying a use-count for each bit in that mask. */
2059 case R_ALPHA_GOTDTPREL:
2060 case R_ALPHA_GOTTPREL:
2061 /* Fetch the got entry from the tables. */
2062 gotent = get_got_entry (abfd, h, r_type, r_symndx, rel->r_addend);
2064 /* The got entry *must* exist, since we should have created it
2065 before during check_relocs. Also note that get_got_entry
2066 assumed this was going to be another use, and so incremented
2067 the use count again. Thus the use count must be at least the
2068 one real use and the "use" we just added. */
2069 if (gotent == NULL || gotent->use_count < 2)
2074 gotent->use_count -= 2;
2085 /* Adjust a symbol defined by a dynamic object and referenced by a
2086 regular object. The current definition is in some section of the
2087 dynamic object, but we're not including those sections. We have to
2088 change the definition to something the rest of the link can
2092 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2093 struct elf_link_hash_entry *h)
2097 struct alpha_elf_link_hash_entry *ah;
2099 dynobj = elf_hash_table(info)->dynobj;
2100 ah = (struct alpha_elf_link_hash_entry *)h;
2102 /* Now that we've seen all of the input symbols, finalize our decision
2103 about whether this symbol should get a .plt entry. Irritatingly, it
2104 is common for folk to leave undefined symbols in shared libraries,
2105 and they still expect lazy binding; accept undefined symbols in lieu
2107 if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2109 h->needs_plt = TRUE;
2111 s = bfd_get_linker_section (dynobj, ".plt");
2112 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2115 /* We need one plt entry per got subsection. Delay allocation of
2116 the actual plt entries until size_plt_section, called from
2117 size_dynamic_sections or during relaxation. */
2122 h->needs_plt = FALSE;
2124 /* If this is a weak symbol, and there is a real definition, the
2125 processor independent code will have arranged for us to see the
2126 real definition first, and we can just use the same value. */
2127 if (h->u.weakdef != NULL)
2129 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2130 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2131 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2132 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2136 /* This is a reference to a symbol defined by a dynamic object which
2137 is not a function. The Alpha, since it uses .got entries for all
2138 symbols even in regular objects, does not need the hackery of a
2139 .dynbss section and COPY dynamic relocations. */
2144 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2147 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2148 const Elf_Internal_Sym *isym,
2149 bfd_boolean definition,
2150 bfd_boolean dynamic)
2152 if (!dynamic && definition)
2153 h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2154 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
2157 /* Symbol versioning can create new symbols, and make our old symbols
2158 indirect to the new ones. Consolidate the got and reloc information
2159 in these situations. */
2162 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2163 struct elf_link_hash_entry *dir,
2164 struct elf_link_hash_entry *ind)
2166 struct alpha_elf_link_hash_entry *hi
2167 = (struct alpha_elf_link_hash_entry *) ind;
2168 struct alpha_elf_link_hash_entry *hs
2169 = (struct alpha_elf_link_hash_entry *) dir;
2171 /* Do the merging in the superclass. */
2172 _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2174 /* Merge the flags. Whee. */
2175 hs->flags |= hi->flags;
2177 /* ??? It's unclear to me what's really supposed to happen when
2178 "merging" defweak and defined symbols, given that we don't
2179 actually throw away the defweak. This more-or-less copies
2180 the logic related to got and plt entries in the superclass. */
2181 if (ind->root.type != bfd_link_hash_indirect)
2184 /* Merge the .got entries. Cannibalize the old symbol's list in
2185 doing so, since we don't need it anymore. */
2187 if (hs->got_entries == NULL)
2188 hs->got_entries = hi->got_entries;
2191 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2193 gsh = hs->got_entries;
2194 for (gi = hi->got_entries; gi ; gi = gin)
2197 for (gs = gsh; gs ; gs = gs->next)
2198 if (gi->gotobj == gs->gotobj
2199 && gi->reloc_type == gs->reloc_type
2200 && gi->addend == gs->addend)
2202 gi->use_count += gs->use_count;
2205 gi->next = hs->got_entries;
2206 hs->got_entries = gi;
2210 hi->got_entries = NULL;
2212 /* And similar for the reloc entries. */
2214 if (hs->reloc_entries == NULL)
2215 hs->reloc_entries = hi->reloc_entries;
2218 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2220 rsh = hs->reloc_entries;
2221 for (ri = hi->reloc_entries; ri ; ri = rin)
2224 for (rs = rsh; rs ; rs = rs->next)
2225 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2227 rs->count += ri->count;
2230 ri->next = hs->reloc_entries;
2231 hs->reloc_entries = ri;
2235 hi->reloc_entries = NULL;
2238 /* Is it possible to merge two object file's .got tables? */
2241 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2243 int total = alpha_elf_tdata (a)->total_got_size;
2246 /* Trivial quick fallout test. */
2247 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2250 /* By their nature, local .got entries cannot be merged. */
2251 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2254 /* Failing the common trivial comparison, we must effectively
2255 perform the merge. Not actually performing the merge means that
2256 we don't have to store undo information in case we fail. */
2257 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2259 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2260 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2263 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2264 for (i = 0; i < n; ++i)
2266 struct alpha_elf_got_entry *ae, *be;
2267 struct alpha_elf_link_hash_entry *h;
2270 while (h->root.root.type == bfd_link_hash_indirect
2271 || h->root.root.type == bfd_link_hash_warning)
2272 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2274 for (be = h->got_entries; be ; be = be->next)
2276 if (be->use_count == 0)
2278 if (be->gotobj != b)
2281 for (ae = h->got_entries; ae ; ae = ae->next)
2283 && ae->reloc_type == be->reloc_type
2284 && ae->addend == be->addend)
2287 total += alpha_got_entry_size (be->reloc_type);
2288 if (total > MAX_GOT_SIZE)
2298 /* Actually merge two .got tables. */
2301 elf64_alpha_merge_gots (bfd *a, bfd *b)
2303 int total = alpha_elf_tdata (a)->total_got_size;
2306 /* Remember local expansion. */
2308 int e = alpha_elf_tdata (b)->local_got_size;
2310 alpha_elf_tdata (a)->local_got_size += e;
2313 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2315 struct alpha_elf_got_entry **local_got_entries;
2316 struct alpha_elf_link_hash_entry **hashes;
2317 Elf_Internal_Shdr *symtab_hdr;
2320 /* Let the local .got entries know they are part of a new subsegment. */
2321 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2322 if (local_got_entries)
2324 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2325 for (i = 0; i < n; ++i)
2327 struct alpha_elf_got_entry *ent;
2328 for (ent = local_got_entries[i]; ent; ent = ent->next)
2333 /* Merge the global .got entries. */
2334 hashes = alpha_elf_sym_hashes (bsub);
2335 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2337 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2338 for (i = 0; i < n; ++i)
2340 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2341 struct alpha_elf_link_hash_entry *h;
2344 while (h->root.root.type == bfd_link_hash_indirect
2345 || h->root.root.type == bfd_link_hash_warning)
2346 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2348 pbe = start = &h->got_entries;
2349 while ((be = *pbe) != NULL)
2351 if (be->use_count == 0)
2354 memset (be, 0xa5, sizeof (*be));
2357 if (be->gotobj != b)
2360 for (ae = *start; ae ; ae = ae->next)
2362 && ae->reloc_type == be->reloc_type
2363 && ae->addend == be->addend)
2365 ae->flags |= be->flags;
2366 ae->use_count += be->use_count;
2368 memset (be, 0xa5, sizeof (*be));
2372 total += alpha_got_entry_size (be->reloc_type);
2380 alpha_elf_tdata (bsub)->gotobj = a;
2382 alpha_elf_tdata (a)->total_got_size = total;
2384 /* Merge the two in_got chains. */
2389 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2392 alpha_elf_tdata (bsub)->in_got_link_next = b;
2396 /* Calculate the offsets for the got entries. */
2399 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2400 void * arg ATTRIBUTE_UNUSED)
2402 struct alpha_elf_got_entry *gotent;
2404 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2405 if (gotent->use_count > 0)
2407 struct alpha_elf_obj_tdata *td;
2408 bfd_size_type *plge;
2410 td = alpha_elf_tdata (gotent->gotobj);
2411 plge = &td->got->size;
2412 gotent->got_offset = *plge;
2413 *plge += alpha_got_entry_size (gotent->reloc_type);
2420 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2423 struct alpha_elf_link_hash_table * htab;
2425 htab = alpha_elf_hash_table (info);
2428 got_list = htab->got_list;
2430 /* First, zero out the .got sizes, as we may be recalculating the
2431 .got after optimizing it. */
2432 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2433 alpha_elf_tdata(i)->got->size = 0;
2435 /* Next, fill in the offsets for all the global entries. */
2436 alpha_elf_link_hash_traverse (htab,
2437 elf64_alpha_calc_got_offsets_for_symbol,
2440 /* Finally, fill in the offsets for the local entries. */
2441 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2443 bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2446 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2448 struct alpha_elf_got_entry **local_got_entries, *gotent;
2451 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2452 if (!local_got_entries)
2455 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2456 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2457 if (gotent->use_count > 0)
2459 gotent->got_offset = got_offset;
2460 got_offset += alpha_got_entry_size (gotent->reloc_type);
2464 alpha_elf_tdata(i)->got->size = got_offset;
2468 /* Constructs the gots. */
2471 elf64_alpha_size_got_sections (struct bfd_link_info *info)
2473 bfd *i, *got_list, *cur_got_obj = NULL;
2474 struct alpha_elf_link_hash_table * htab;
2476 htab = alpha_elf_hash_table (info);
2479 got_list = htab->got_list;
2481 /* On the first time through, pretend we have an existing got list
2482 consisting of all of the input files. */
2483 if (got_list == NULL)
2485 for (i = info->input_bfds; i ; i = i->link_next)
2489 if (! is_alpha_elf (i))
2492 this_got = alpha_elf_tdata (i)->gotobj;
2493 if (this_got == NULL)
2496 /* We are assuming no merging has yet occurred. */
2497 BFD_ASSERT (this_got == i);
2499 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2501 /* Yikes! A single object file has too many entries. */
2502 (*_bfd_error_handler)
2503 (_("%B: .got subsegment exceeds 64K (size %d)"),
2504 i, alpha_elf_tdata (this_got)->total_got_size);
2508 if (got_list == NULL)
2509 got_list = this_got;
2511 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2512 cur_got_obj = this_got;
2515 /* Strange degenerate case of no got references. */
2516 if (got_list == NULL)
2519 htab->got_list = got_list;
2522 cur_got_obj = got_list;
2523 if (cur_got_obj == NULL)
2526 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2529 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2531 elf64_alpha_merge_gots (cur_got_obj, i);
2533 alpha_elf_tdata(i)->got->size = 0;
2534 i = alpha_elf_tdata(i)->got_link_next;
2535 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2540 i = alpha_elf_tdata(i)->got_link_next;
2544 /* Once the gots have been merged, fill in the got offsets for
2545 everything therein. */
2546 elf64_alpha_calc_got_offsets (info);
2552 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2555 asection *splt = (asection *) data;
2556 struct alpha_elf_got_entry *gotent;
2557 bfd_boolean saw_one = FALSE;
2559 /* If we didn't need an entry before, we still don't. */
2560 if (!h->root.needs_plt)
2563 /* For each LITERAL got entry still in use, allocate a plt entry. */
2564 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2565 if (gotent->reloc_type == R_ALPHA_LITERAL
2566 && gotent->use_count > 0)
2568 if (splt->size == 0)
2569 splt->size = PLT_HEADER_SIZE;
2570 gotent->plt_offset = splt->size;
2571 splt->size += PLT_ENTRY_SIZE;
2575 /* If there weren't any, there's no longer a need for the PLT entry. */
2577 h->root.needs_plt = FALSE;
2582 /* Called from relax_section to rebuild the PLT in light of potential changes
2583 in the function's status. */
2586 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2588 asection *splt, *spltrel, *sgotplt;
2589 unsigned long entries;
2591 struct alpha_elf_link_hash_table * htab;
2593 htab = alpha_elf_hash_table (info);
2597 dynobj = elf_hash_table(info)->dynobj;
2598 splt = bfd_get_linker_section (dynobj, ".plt");
2604 alpha_elf_link_hash_traverse (htab,
2605 elf64_alpha_size_plt_section_1, splt);
2607 /* Every plt entry requires a JMP_SLOT relocation. */
2608 spltrel = bfd_get_linker_section (dynobj, ".rela.plt");
2612 if (elf64_alpha_use_secureplt)
2613 entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2615 entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2617 spltrel->size = entries * sizeof (Elf64_External_Rela);
2619 /* When using the secureplt, we need two words somewhere in the data
2620 segment for the dynamic linker to tell us where to go. This is the
2621 entire contents of the .got.plt section. */
2622 if (elf64_alpha_use_secureplt)
2624 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
2625 sgotplt->size = entries ? 16 : 0;
2630 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2631 struct bfd_link_info *info)
2634 struct alpha_elf_link_hash_table * htab;
2636 if (info->relocatable)
2639 htab = alpha_elf_hash_table (info);
2643 if (!elf64_alpha_size_got_sections (info))
2646 /* Allocate space for all of the .got subsections. */
2648 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2650 asection *s = alpha_elf_tdata(i)->got;
2653 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2654 if (s->contents == NULL)
2662 /* The number of dynamic relocations required by a static relocation. */
2665 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2669 /* May appear in GOT entries. */
2671 return (dynamic ? 2 : shared ? 1 : 0);
2672 case R_ALPHA_TLSLDM:
2674 case R_ALPHA_LITERAL:
2675 return dynamic || shared;
2676 case R_ALPHA_GOTTPREL:
2677 return dynamic || (shared && !pie);
2678 case R_ALPHA_GOTDTPREL:
2681 /* May appear in data sections. */
2682 case R_ALPHA_REFLONG:
2683 case R_ALPHA_REFQUAD:
2684 return dynamic || shared;
2685 case R_ALPHA_TPREL64:
2686 return dynamic || (shared && !pie);
2688 /* Everything else is illegal. We'll issue an error during
2689 relocate_section. */
2695 /* Work out the sizes of the dynamic relocation entries. */
2698 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2699 struct bfd_link_info *info)
2701 bfd_boolean dynamic;
2702 struct alpha_elf_reloc_entry *relent;
2703 unsigned long entries;
2705 /* If the symbol was defined as a common symbol in a regular object
2706 file, and there was no definition in any dynamic object, then the
2707 linker will have allocated space for the symbol in a common
2708 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2709 set. This is done for dynamic symbols in
2710 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2711 symbols, somehow. */
2712 if (!h->root.def_regular
2713 && h->root.ref_regular
2714 && !h->root.def_dynamic
2715 && (h->root.root.type == bfd_link_hash_defined
2716 || h->root.root.type == bfd_link_hash_defweak)
2717 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2718 h->root.def_regular = 1;
2720 /* If the symbol is dynamic, we'll need all the relocations in their
2721 natural form. If this is a shared object, and it has been forced
2722 local, we'll need the same number of RELATIVE relocations. */
2723 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2725 /* If the symbol is a hidden undefined weak, then we never have any
2726 relocations. Avoid the loop which may want to add RELATIVE relocs
2727 based on info->shared. */
2728 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2731 for (relent = h->reloc_entries; relent; relent = relent->next)
2733 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2734 info->shared, info->pie);
2737 relent->srel->size +=
2738 entries * sizeof (Elf64_External_Rela) * relent->count;
2739 if (relent->reltext)
2740 info->flags |= DT_TEXTREL;
2747 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2751 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2752 struct bfd_link_info *info)
2754 bfd_boolean dynamic;
2755 struct alpha_elf_got_entry *gotent;
2756 unsigned long entries;
2758 /* If we're using a plt for this symbol, then all of its relocations
2759 for its got entries go into .rela.plt. */
2760 if (h->root.needs_plt)
2763 /* If the symbol is dynamic, we'll need all the relocations in their
2764 natural form. If this is a shared object, and it has been forced
2765 local, we'll need the same number of RELATIVE relocations. */
2766 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2768 /* If the symbol is a hidden undefined weak, then we never have any
2769 relocations. Avoid the loop which may want to add RELATIVE relocs
2770 based on info->shared. */
2771 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2775 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2776 if (gotent->use_count > 0)
2777 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2778 info->shared, info->pie);
2782 bfd *dynobj = elf_hash_table(info)->dynobj;
2783 asection *srel = bfd_get_linker_section (dynobj, ".rela.got");
2784 BFD_ASSERT (srel != NULL);
2785 srel->size += sizeof (Elf64_External_Rela) * entries;
2791 /* Set the sizes of the dynamic relocation sections. */
2794 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2796 unsigned long entries;
2799 struct alpha_elf_link_hash_table * htab;
2801 htab = alpha_elf_hash_table (info);
2805 /* Shared libraries often require RELATIVE relocs, and some relocs
2806 require attention for the main application as well. */
2809 for (i = htab->got_list;
2810 i ; i = alpha_elf_tdata(i)->got_link_next)
2814 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2816 struct alpha_elf_got_entry **local_got_entries, *gotent;
2819 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2820 if (!local_got_entries)
2823 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2824 for (gotent = local_got_entries[k];
2825 gotent ; gotent = gotent->next)
2826 if (gotent->use_count > 0)
2827 entries += (alpha_dynamic_entries_for_reloc
2828 (gotent->reloc_type, 0, info->shared, info->pie));
2832 dynobj = elf_hash_table(info)->dynobj;
2833 srel = bfd_get_linker_section (dynobj, ".rela.got");
2836 BFD_ASSERT (entries == 0);
2839 srel->size = sizeof (Elf64_External_Rela) * entries;
2841 /* Now do the non-local symbols. */
2842 alpha_elf_link_hash_traverse (htab,
2843 elf64_alpha_size_rela_got_1, info);
2846 /* Set the sizes of the dynamic sections. */
2849 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2850 struct bfd_link_info *info)
2855 struct alpha_elf_link_hash_table * htab;
2857 htab = alpha_elf_hash_table (info);
2861 dynobj = elf_hash_table(info)->dynobj;
2862 BFD_ASSERT(dynobj != NULL);
2864 if (elf_hash_table (info)->dynamic_sections_created)
2866 /* Set the contents of the .interp section to the interpreter. */
2867 if (info->executable)
2869 s = bfd_get_linker_section (dynobj, ".interp");
2870 BFD_ASSERT (s != NULL);
2871 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2872 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2875 /* Now that we've seen all of the input files, we can decide which
2876 symbols need dynamic relocation entries and which don't. We've
2877 collected information in check_relocs that we can now apply to
2878 size the dynamic relocation sections. */
2879 alpha_elf_link_hash_traverse (htab,
2880 elf64_alpha_calc_dynrel_sizes, info);
2882 elf64_alpha_size_rela_got_section (info);
2883 elf64_alpha_size_plt_section (info);
2885 /* else we're not dynamic and by definition we don't need such things. */
2887 /* The check_relocs and adjust_dynamic_symbol entry points have
2888 determined the sizes of the various dynamic sections. Allocate
2891 for (s = dynobj->sections; s != NULL; s = s->next)
2895 if (!(s->flags & SEC_LINKER_CREATED))
2898 /* It's OK to base decisions on the section name, because none
2899 of the dynobj section names depend upon the input files. */
2900 name = bfd_get_section_name (dynobj, s);
2902 if (CONST_STRNEQ (name, ".rela"))
2906 if (strcmp (name, ".rela.plt") == 0)
2909 /* We use the reloc_count field as a counter if we need
2910 to copy relocs into the output file. */
2914 else if (! CONST_STRNEQ (name, ".got")
2915 && strcmp (name, ".plt") != 0
2916 && strcmp (name, ".dynbss") != 0)
2918 /* It's not one of our dynamic sections, so don't allocate space. */
2924 /* If we don't need this section, strip it from the output file.
2925 This is to handle .rela.bss and .rela.plt. We must create it
2926 in create_dynamic_sections, because it must be created before
2927 the linker maps input sections to output sections. The
2928 linker does that before adjust_dynamic_symbol is called, and
2929 it is that function which decides whether anything needs to
2930 go into these sections. */
2931 if (!CONST_STRNEQ (name, ".got"))
2932 s->flags |= SEC_EXCLUDE;
2934 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2936 /* Allocate memory for the section contents. */
2937 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2938 if (s->contents == NULL)
2943 if (elf_hash_table (info)->dynamic_sections_created)
2945 /* Add some entries to the .dynamic section. We fill in the
2946 values later, in elf64_alpha_finish_dynamic_sections, but we
2947 must add the entries now so that we get the correct size for
2948 the .dynamic section. The DT_DEBUG entry is filled in by the
2949 dynamic linker and used by the debugger. */
2950 #define add_dynamic_entry(TAG, VAL) \
2951 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2953 if (info->executable)
2955 if (!add_dynamic_entry (DT_DEBUG, 0))
2961 if (!add_dynamic_entry (DT_PLTGOT, 0)
2962 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2963 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2964 || !add_dynamic_entry (DT_JMPREL, 0))
2967 if (elf64_alpha_use_secureplt
2968 && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2972 if (!add_dynamic_entry (DT_RELA, 0)
2973 || !add_dynamic_entry (DT_RELASZ, 0)
2974 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2977 if (info->flags & DF_TEXTREL)
2979 if (!add_dynamic_entry (DT_TEXTREL, 0))
2983 #undef add_dynamic_entry
2988 /* These functions do relaxation for Alpha ELF.
2990 Currently I'm only handling what I can do with existing compiler
2991 and assembler support, which means no instructions are removed,
2992 though some may be nopped. At this time GCC does not emit enough
2993 information to do all of the relaxing that is possible. It will
2994 take some not small amount of work for that to happen.
2996 There are a couple of interesting papers that I once read on this
2997 subject, that I cannot find references to at the moment, that
2998 related to Alpha in particular. They are by David Wall, then of
3001 struct alpha_relax_info
3006 Elf_Internal_Shdr *symtab_hdr;
3007 Elf_Internal_Rela *relocs, *relend;
3008 struct bfd_link_info *link_info;
3012 struct alpha_elf_link_hash_entry *h;
3013 struct alpha_elf_got_entry **first_gotent;
3014 struct alpha_elf_got_entry *gotent;
3015 bfd_boolean changed_contents;
3016 bfd_boolean changed_relocs;
3017 unsigned char other;
3020 static Elf_Internal_Rela *
3021 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
3022 Elf_Internal_Rela *relend,
3023 bfd_vma offset, int type)
3025 while (rel < relend)
3027 if (rel->r_offset == offset
3028 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
3036 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3037 Elf_Internal_Rela *irel, unsigned long r_type)
3040 bfd_signed_vma disp;
3042 /* Get the instruction. */
3043 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3045 if (insn >> 26 != OP_LDQ)
3047 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3048 ((*_bfd_error_handler)
3049 ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
3050 info->abfd, info->sec,
3051 (unsigned long) irel->r_offset, howto->name));
3055 /* Can't relax dynamic symbols. */
3056 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3059 /* Can't use local-exec relocations in shared libraries. */
3060 if (r_type == R_ALPHA_GOTTPREL
3061 && (info->link_info->shared && !info->link_info->pie))
3064 if (r_type == R_ALPHA_LITERAL)
3066 /* Look for nice constant addresses. This includes the not-uncommon
3067 special case of 0 for undefweak symbols. */
3068 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3069 || (!info->link_info->shared
3070 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3073 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3074 insn |= (symval & 0xffff);
3075 r_type = R_ALPHA_NONE;
3079 disp = symval - info->gp;
3080 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3081 r_type = R_ALPHA_GPREL16;
3086 bfd_vma dtp_base, tp_base;
3088 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3089 dtp_base = alpha_get_dtprel_base (info->link_info);
3090 tp_base = alpha_get_tprel_base (info->link_info);
3091 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3093 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3097 case R_ALPHA_GOTDTPREL:
3098 r_type = R_ALPHA_DTPREL16;
3100 case R_ALPHA_GOTTPREL:
3101 r_type = R_ALPHA_TPREL16;
3109 if (disp < -0x8000 || disp >= 0x8000)
3112 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3113 info->changed_contents = TRUE;
3115 /* Reduce the use count on this got entry by one, possibly
3117 if (--info->gotent->use_count == 0)
3119 int sz = alpha_got_entry_size (r_type);
3120 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3122 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3125 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3126 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3127 info->changed_relocs = TRUE;
3129 /* ??? Search forward through this basic block looking for insns
3130 that use the target register. Stop after an insn modifying the
3131 register is seen, or after a branch or call.
3133 Any such memory load insn may be substituted by a load directly
3134 off the GP. This allows the memory load insn to be issued before
3135 the calculated GP register would otherwise be ready.
3137 Any such jsr insn can be replaced by a bsr if it is in range.
3139 This would mean that we'd have to _add_ relocations, the pain of
3140 which gives one pause. */
3146 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3148 /* If the function has the same gp, and we can identify that the
3149 function does not use its function pointer, we can eliminate the
3152 /* If the symbol is marked NOPV, we are being told the function never
3153 needs its procedure value. */
3154 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3157 /* If the symbol is marked STD_GP, we are being told the function does
3158 a normal ldgp in the first two words. */
3159 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3162 /* Otherwise, we may be able to identify a GP load in the first two
3163 words, which we can then skip. */
3166 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3169 /* Load the relocations from the section that the target symbol is in. */
3170 if (info->sec == info->tsec)
3172 tsec_relocs = info->relocs;
3173 tsec_relend = info->relend;
3178 tsec_relocs = (_bfd_elf_link_read_relocs
3179 (info->abfd, info->tsec, NULL,
3180 (Elf_Internal_Rela *) NULL,
3181 info->link_info->keep_memory));
3182 if (tsec_relocs == NULL)
3184 tsec_relend = tsec_relocs + info->tsec->reloc_count;
3185 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
3188 /* Recover the symbol's offset within the section. */
3189 ofs = (symval - info->tsec->output_section->vma
3190 - info->tsec->output_offset);
3192 /* Look for a GPDISP reloc. */
3193 gpdisp = (elf64_alpha_find_reloc_at_ofs
3194 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3196 if (!gpdisp || gpdisp->r_addend != 4)
3206 /* We've now determined that we can skip an initial gp load. Verify
3207 that the call and the target use the same gp. */
3208 if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3209 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3216 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3217 bfd_vma symval, Elf_Internal_Rela *irel)
3219 Elf_Internal_Rela *urel, *irelend = info->relend;
3220 int flags, count, i;
3221 bfd_signed_vma disp;
3224 bfd_boolean lit_reused = FALSE;
3225 bfd_boolean all_optimized = TRUE;
3226 unsigned int lit_insn;
3228 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3229 if (lit_insn >> 26 != OP_LDQ)
3231 ((*_bfd_error_handler)
3232 ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
3233 info->abfd, info->sec,
3234 (unsigned long) irel->r_offset));
3238 /* Can't relax dynamic symbols. */
3239 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3242 /* Summarize how this particular LITERAL is used. */
3243 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
3245 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
3247 if (urel->r_addend <= 6)
3248 flags |= 1 << urel->r_addend;
3251 /* A little preparation for the loop... */
3252 disp = symval - info->gp;
3254 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
3258 bfd_signed_vma xdisp;
3260 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
3262 switch (urel->r_addend)
3264 case LITUSE_ALPHA_ADDR:
3266 /* This type is really just a placeholder to note that all
3267 uses cannot be optimized, but to still allow some. */
3268 all_optimized = FALSE;
3271 case LITUSE_ALPHA_BASE:
3272 /* We can always optimize 16-bit displacements. */
3274 /* Extract the displacement from the instruction, sign-extending
3275 it if necessary, then test whether it is within 16 or 32 bits
3276 displacement from GP. */
3277 insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3279 xdisp = disp + insn_disp;
3280 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3281 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3282 && xdisp < 0x7fff8000);
3286 /* Take the op code and dest from this insn, take the base
3287 register from the literal insn. Leave the offset alone. */
3288 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3289 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3291 urel->r_addend = irel->r_addend;
3292 info->changed_relocs = TRUE;
3294 bfd_put_32 (info->abfd, (bfd_vma) insn,
3295 info->contents + urel->r_offset);
3296 info->changed_contents = TRUE;
3299 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3300 else if (fits32 && !(flags & ~6))
3302 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3304 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3306 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3307 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
3308 info->contents + irel->r_offset);
3310 info->changed_contents = TRUE;
3312 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3314 urel->r_addend = irel->r_addend;
3315 info->changed_relocs = TRUE;
3318 all_optimized = FALSE;
3321 case LITUSE_ALPHA_BYTOFF:
3322 /* We can always optimize byte instructions. */
3324 /* FIXME: sanity check the insn for byte op. Check that the
3325 literal dest reg is indeed Rb in the byte insn. */
3327 insn &= ~ (unsigned) 0x001ff000;
3328 insn |= ((symval & 7) << 13) | 0x1000;
3330 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3332 info->changed_relocs = TRUE;
3334 bfd_put_32 (info->abfd, (bfd_vma) insn,
3335 info->contents + urel->r_offset);
3336 info->changed_contents = TRUE;
3339 case LITUSE_ALPHA_JSR:
3340 case LITUSE_ALPHA_TLSGD:
3341 case LITUSE_ALPHA_TLSLDM:
3342 case LITUSE_ALPHA_JSRDIRECT:
3344 bfd_vma optdest, org;
3345 bfd_signed_vma odisp;
3347 /* For undefined weak symbols, we're mostly interested in getting
3348 rid of the got entry whenever possible, so optimize this to a
3349 use of the zero register. */
3350 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3353 bfd_put_32 (info->abfd, (bfd_vma) insn,
3354 info->contents + urel->r_offset);
3356 info->changed_contents = TRUE;
3360 /* If not zero, place to jump without needing pv. */
3361 optdest = elf64_alpha_relax_opt_call (info, symval);
3362 org = (info->sec->output_section->vma
3363 + info->sec->output_offset
3364 + urel->r_offset + 4);
3365 odisp = (optdest ? optdest : symval) - org;
3367 if (odisp >= -0x400000 && odisp < 0x400000)
3369 Elf_Internal_Rela *xrel;
3371 /* Preserve branch prediction call stack when possible. */
3372 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3373 insn = (OP_BSR << 26) | (insn & 0x03e00000);
3375 insn = (OP_BR << 26) | (insn & 0x03e00000);
3377 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3379 urel->r_addend = irel->r_addend;
3382 urel->r_addend += optdest - symval;
3384 all_optimized = FALSE;
3386 bfd_put_32 (info->abfd, (bfd_vma) insn,
3387 info->contents + urel->r_offset);
3389 /* Kill any HINT reloc that might exist for this insn. */
3390 xrel = (elf64_alpha_find_reloc_at_ofs
3391 (info->relocs, info->relend, urel->r_offset,
3394 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3396 info->changed_contents = TRUE;
3397 info->changed_relocs = TRUE;
3400 all_optimized = FALSE;
3402 /* Even if the target is not in range for a direct branch,
3403 if we share a GP, we can eliminate the gp reload. */
3406 Elf_Internal_Rela *gpdisp
3407 = (elf64_alpha_find_reloc_at_ofs
3408 (info->relocs, irelend, urel->r_offset + 4,
3412 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
3413 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3414 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
3415 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
3417 /* Verify that the instruction is "ldah $29,0($26)".
3418 Consider a function that ends in a noreturn call,
3419 and that the next function begins with an ldgp,
3420 and that by accident there is no padding between.
3421 In that case the insn would use $27 as the base. */
3422 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3424 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
3425 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
3427 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3428 info->changed_contents = TRUE;
3429 info->changed_relocs = TRUE;
3438 /* If all cases were optimized, we can reduce the use count on this
3439 got entry by one, possibly eliminating it. */
3442 if (--info->gotent->use_count == 0)
3444 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3445 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3447 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3450 /* If the literal instruction is no longer needed (it may have been
3451 reused. We can eliminate it. */
3452 /* ??? For now, I don't want to deal with compacting the section,
3453 so just nop it out. */
3456 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3457 info->changed_relocs = TRUE;
3459 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
3460 info->contents + irel->r_offset);
3461 info->changed_contents = TRUE;
3467 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3471 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3472 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3475 unsigned int insn, tlsgd_reg;
3476 Elf_Internal_Rela *gpdisp, *hint;
3477 bfd_boolean dynamic, use_gottprel;
3478 unsigned long new_symndx;
3480 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3482 /* If a TLS symbol is accessed using IE at least once, there is no point
3483 to use dynamic model for it. */
3484 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3487 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3488 then we might as well relax to IE. */
3489 else if (info->link_info->shared && !dynamic
3490 && (info->link_info->flags & DF_STATIC_TLS))
3493 /* Otherwise we must be building an executable to do anything. */
3494 else if (info->link_info->shared)
3497 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3498 the matching LITUSE_TLS relocations. */
3499 if (irel + 2 >= info->relend)
3501 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3502 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3503 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3506 /* There must be a GPDISP relocation positioned immediately after the
3507 LITUSE relocation. */
3508 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3509 irel[2].r_offset + 4, R_ALPHA_GPDISP);
3513 pos[0] = info->contents + irel[0].r_offset;
3514 pos[1] = info->contents + irel[1].r_offset;
3515 pos[2] = info->contents + irel[2].r_offset;
3516 pos[3] = info->contents + gpdisp->r_offset;
3517 pos[4] = pos[3] + gpdisp->r_addend;
3519 /* Beware of the compiler hoisting part of the sequence out a loop
3520 and adjusting the destination register for the TLSGD insn. If this
3521 happens, there will be a move into $16 before the JSR insn, so only
3522 transformations of the first insn pair should use this register. */
3523 tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3524 tlsgd_reg = (tlsgd_reg >> 21) & 31;
3526 /* Generally, the positions are not allowed to be out of order, lest the
3527 modified insn sequence have different register lifetimes. We can make
3528 an exception when pos 1 is adjacent to pos 0. */
3529 if (pos[1] + 4 == pos[0])
3531 bfd_byte *tmp = pos[0];
3535 if (pos[1] >= pos[2] || pos[2] >= pos[3])
3538 /* Reduce the use count on the LITERAL relocation. Do this before we
3539 smash the symndx when we adjust the relocations below. */
3541 struct alpha_elf_got_entry *lit_gotent;
3542 struct alpha_elf_link_hash_entry *lit_h;
3545 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3546 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3547 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3549 while (lit_h->root.root.type == bfd_link_hash_indirect
3550 || lit_h->root.root.type == bfd_link_hash_warning)
3551 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3553 for (lit_gotent = lit_h->got_entries; lit_gotent ;
3554 lit_gotent = lit_gotent->next)
3555 if (lit_gotent->gotobj == info->gotobj
3556 && lit_gotent->reloc_type == R_ALPHA_LITERAL
3557 && lit_gotent->addend == irel[1].r_addend)
3559 BFD_ASSERT (lit_gotent);
3561 if (--lit_gotent->use_count == 0)
3563 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3564 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3570 lda $16,x($gp) !tlsgd!1
3571 ldq $27,__tls_get_addr($gp) !literal!1
3572 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3573 ldah $29,0($26) !gpdisp!2
3574 lda $29,0($29) !gpdisp!2
3576 ldq $16,x($gp) !gottprel
3581 or the first pair to
3582 lda $16,x($gp) !tprel
3585 ldah $16,x($gp) !tprelhi
3586 lda $16,x($16) !tprello
3590 use_gottprel = FALSE;
3591 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3593 /* Some compilers warn about a Boolean-looking expression being
3594 used in a switch. The explicit cast silences them. */
3595 switch ((int) (!dynamic && !info->link_info->shared))
3600 bfd_signed_vma disp;
3602 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3603 tp_base = alpha_get_tprel_base (info->link_info);
3604 disp = symval - tp_base;
3606 if (disp >= -0x8000 && disp < 0x8000)
3608 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3609 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3610 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3612 irel[0].r_offset = pos[0] - info->contents;
3613 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3614 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3617 else if (disp >= -(bfd_signed_vma) 0x80000000
3618 && disp < (bfd_signed_vma) 0x7fff8000
3619 && pos[0] + 4 == pos[1])
3621 insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3622 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3623 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3624 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3626 irel[0].r_offset = pos[0] - info->contents;
3627 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3628 irel[1].r_offset = pos[1] - info->contents;
3629 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3636 use_gottprel = TRUE;
3638 insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3639 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3640 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3642 irel[0].r_offset = pos[0] - info->contents;
3643 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3644 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3648 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3650 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3651 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3653 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3655 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3656 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3658 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3659 irel[2].r_offset, R_ALPHA_HINT);
3661 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3663 info->changed_contents = TRUE;
3664 info->changed_relocs = TRUE;
3666 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3667 if (--info->gotent->use_count == 0)
3669 int sz = alpha_got_entry_size (info->gotent->reloc_type);
3670 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3672 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3675 /* If we've switched to a GOTTPREL relocation, increment the reference
3676 count on that got entry. */
3679 struct alpha_elf_got_entry *tprel_gotent;
3681 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3682 tprel_gotent = tprel_gotent->next)
3683 if (tprel_gotent->gotobj == info->gotobj
3684 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3685 && tprel_gotent->addend == irel->r_addend)
3688 tprel_gotent->use_count++;
3691 if (info->gotent->use_count == 0)
3692 tprel_gotent = info->gotent;
3695 tprel_gotent = (struct alpha_elf_got_entry *)
3696 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3700 tprel_gotent->next = *info->first_gotent;
3701 *info->first_gotent = tprel_gotent;
3703 tprel_gotent->gotobj = info->gotobj;
3704 tprel_gotent->addend = irel->r_addend;
3705 tprel_gotent->got_offset = -1;
3706 tprel_gotent->reloc_done = 0;
3707 tprel_gotent->reloc_xlated = 0;
3710 tprel_gotent->use_count = 1;
3711 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3719 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3720 struct bfd_link_info *link_info, bfd_boolean *again)
3722 Elf_Internal_Shdr *symtab_hdr;
3723 Elf_Internal_Rela *internal_relocs;
3724 Elf_Internal_Rela *irel, *irelend;
3725 Elf_Internal_Sym *isymbuf = NULL;
3726 struct alpha_elf_got_entry **local_got_entries;
3727 struct alpha_relax_info info;
3728 struct alpha_elf_link_hash_table * htab;
3730 htab = alpha_elf_hash_table (link_info);
3734 /* There's nothing to change, yet. */
3737 if (link_info->relocatable
3738 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3739 != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3740 || sec->reloc_count == 0)
3743 BFD_ASSERT (is_alpha_elf (abfd));
3745 /* Make sure our GOT and PLT tables are up-to-date. */
3746 if (htab->relax_trip != link_info->relax_trip)
3748 htab->relax_trip = link_info->relax_trip;
3750 /* This should never fail after the initial round, since the only
3751 error is GOT overflow, and relaxation only shrinks the table. */
3752 if (!elf64_alpha_size_got_sections (link_info))
3754 if (elf_hash_table (link_info)->dynamic_sections_created)
3756 elf64_alpha_size_plt_section (link_info);
3757 elf64_alpha_size_rela_got_section (link_info);
3761 symtab_hdr = &elf_symtab_hdr (abfd);
3762 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3764 /* Load the relocations for this section. */
3765 internal_relocs = (_bfd_elf_link_read_relocs
3766 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3767 link_info->keep_memory));
3768 if (internal_relocs == NULL)
3771 memset(&info, 0, sizeof (info));
3774 info.link_info = link_info;
3775 info.symtab_hdr = symtab_hdr;
3776 info.relocs = internal_relocs;
3777 info.relend = irelend = internal_relocs + sec->reloc_count;
3779 /* Find the GP for this object. Do not store the result back via
3780 _bfd_set_gp_value, since this could change again before final. */
3781 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3784 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3785 info.gp = (sgot->output_section->vma
3786 + sgot->output_offset
3790 /* Get the section contents. */
3791 if (elf_section_data (sec)->this_hdr.contents != NULL)
3792 info.contents = elf_section_data (sec)->this_hdr.contents;
3795 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3799 for (irel = internal_relocs; irel < irelend; irel++)
3802 struct alpha_elf_got_entry *gotent;
3803 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3804 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3806 /* Early exit for unhandled or unrelaxable relocations. */
3809 case R_ALPHA_LITERAL:
3810 case R_ALPHA_GPRELHIGH:
3811 case R_ALPHA_GPRELLOW:
3812 case R_ALPHA_GOTDTPREL:
3813 case R_ALPHA_GOTTPREL:
3817 case R_ALPHA_TLSLDM:
3818 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3819 reloc to the STN_UNDEF (0) symbol so that they all match. */
3820 r_symndx = STN_UNDEF;
3827 /* Get the value of the symbol referred to by the reloc. */
3828 if (r_symndx < symtab_hdr->sh_info)
3830 /* A local symbol. */
3831 Elf_Internal_Sym *isym;
3833 /* Read this BFD's local symbols. */
3834 if (isymbuf == NULL)
3836 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3837 if (isymbuf == NULL)
3838 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3839 symtab_hdr->sh_info, 0,
3841 if (isymbuf == NULL)
3845 isym = isymbuf + r_symndx;
3847 /* Given the symbol for a TLSLDM reloc is ignored, this also
3848 means forcing the symbol value to the tp base. */
3849 if (r_type == R_ALPHA_TLSLDM)
3851 info.tsec = bfd_abs_section_ptr;
3852 symval = alpha_get_tprel_base (info.link_info);
3856 symval = isym->st_value;
3857 if (isym->st_shndx == SHN_UNDEF)
3859 else if (isym->st_shndx == SHN_ABS)
3860 info.tsec = bfd_abs_section_ptr;
3861 else if (isym->st_shndx == SHN_COMMON)
3862 info.tsec = bfd_com_section_ptr;
3864 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3868 info.other = isym->st_other;
3869 if (local_got_entries)
3870 info.first_gotent = &local_got_entries[r_symndx];
3873 info.first_gotent = &info.gotent;
3880 struct alpha_elf_link_hash_entry *h;
3882 indx = r_symndx - symtab_hdr->sh_info;
3883 h = alpha_elf_sym_hashes (abfd)[indx];
3884 BFD_ASSERT (h != NULL);
3886 while (h->root.root.type == bfd_link_hash_indirect
3887 || h->root.root.type == bfd_link_hash_warning)
3888 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3890 /* If the symbol is undefined, we can't do anything with it. */
3891 if (h->root.root.type == bfd_link_hash_undefined)
3894 /* If the symbol isn't defined in the current module,
3895 again we can't do anything. */
3896 if (h->root.root.type == bfd_link_hash_undefweak)
3898 info.tsec = bfd_abs_section_ptr;
3901 else if (!h->root.def_regular)
3903 /* Except for TLSGD relocs, which can sometimes be
3904 relaxed to GOTTPREL relocs. */
3905 if (r_type != R_ALPHA_TLSGD)
3907 info.tsec = bfd_abs_section_ptr;
3912 info.tsec = h->root.root.u.def.section;
3913 symval = h->root.root.u.def.value;
3917 info.other = h->root.other;
3918 info.first_gotent = &h->got_entries;
3921 /* Search for the got entry to be used by this relocation. */
3922 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3923 if (gotent->gotobj == info.gotobj
3924 && gotent->reloc_type == r_type
3925 && gotent->addend == irel->r_addend)
3927 info.gotent = gotent;
3929 symval += info.tsec->output_section->vma + info.tsec->output_offset;
3930 symval += irel->r_addend;
3934 case R_ALPHA_LITERAL:
3935 BFD_ASSERT(info.gotent != NULL);
3937 /* If there exist LITUSE relocations immediately following, this
3938 opens up all sorts of interesting optimizations, because we
3939 now know every location that this address load is used. */
3940 if (irel+1 < irelend
3941 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
3943 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
3948 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3953 case R_ALPHA_GOTDTPREL:
3954 case R_ALPHA_GOTTPREL:
3955 BFD_ASSERT(info.gotent != NULL);
3956 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3961 case R_ALPHA_TLSLDM:
3962 BFD_ASSERT(info.gotent != NULL);
3963 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
3964 r_type == R_ALPHA_TLSGD))
3971 && symtab_hdr->contents != (unsigned char *) isymbuf)
3973 if (!link_info->keep_memory)
3977 /* Cache the symbols for elf_link_input_bfd. */
3978 symtab_hdr->contents = (unsigned char *) isymbuf;
3982 if (info.contents != NULL
3983 && elf_section_data (sec)->this_hdr.contents != info.contents)
3985 if (!info.changed_contents && !link_info->keep_memory)
3986 free (info.contents);
3989 /* Cache the section contents for elf_link_input_bfd. */
3990 elf_section_data (sec)->this_hdr.contents = info.contents;
3994 if (elf_section_data (sec)->relocs != internal_relocs)
3996 if (!info.changed_relocs)
3997 free (internal_relocs);
3999 elf_section_data (sec)->relocs = internal_relocs;
4002 *again = info.changed_contents || info.changed_relocs;
4008 && symtab_hdr->contents != (unsigned char *) isymbuf)
4010 if (info.contents != NULL
4011 && elf_section_data (sec)->this_hdr.contents != info.contents)
4012 free (info.contents);
4013 if (internal_relocs != NULL
4014 && elf_section_data (sec)->relocs != internal_relocs)
4015 free (internal_relocs);
4019 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4020 into the next available slot in SREL. */
4023 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4024 asection *sec, asection *srel, bfd_vma offset,
4025 long dynindx, long rtype, bfd_vma addend)
4027 Elf_Internal_Rela outrel;
4030 BFD_ASSERT (srel != NULL);
4032 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4033 outrel.r_addend = addend;
4035 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4036 if ((offset | 1) != (bfd_vma) -1)
4037 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4039 memset (&outrel, 0, sizeof (outrel));
4041 loc = srel->contents;
4042 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4043 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4044 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4047 /* Relocate an Alpha ELF section for a relocatable link.
4049 We don't have to change anything unless the reloc is against a section
4050 symbol, in which case we have to adjust according to where the section
4051 symbol winds up in the output section. */
4054 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4055 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4056 bfd *input_bfd, asection *input_section,
4057 bfd_byte *contents ATTRIBUTE_UNUSED,
4058 Elf_Internal_Rela *relocs,
4059 Elf_Internal_Sym *local_syms,
4060 asection **local_sections)
4062 unsigned long symtab_hdr_sh_info;
4063 Elf_Internal_Rela *rel;
4064 Elf_Internal_Rela *relend;
4065 struct elf_link_hash_entry **sym_hashes;
4066 bfd_boolean ret_val = TRUE;
4068 symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4069 sym_hashes = elf_sym_hashes (input_bfd);
4071 relend = relocs + input_section->reloc_count;
4072 for (rel = relocs; rel < relend; rel++)
4074 unsigned long r_symndx;
4075 Elf_Internal_Sym *sym;
4077 unsigned long r_type;
4079 r_type = ELF64_R_TYPE (rel->r_info);
4080 if (r_type >= R_ALPHA_max)
4082 (*_bfd_error_handler)
4083 (_("%B: unknown relocation type %d"),
4084 input_bfd, (int) r_type);
4085 bfd_set_error (bfd_error_bad_value);
4090 /* The symbol associated with GPDISP and LITUSE is
4091 immaterial. Only the addend is significant. */
4092 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4095 r_symndx = ELF64_R_SYM (rel->r_info);
4096 if (r_symndx < symtab_hdr_sh_info)
4098 sym = local_syms + r_symndx;
4099 sec = local_sections[r_symndx];
4103 struct elf_link_hash_entry *h;
4105 h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4107 while (h->root.type == bfd_link_hash_indirect
4108 || h->root.type == bfd_link_hash_warning)
4109 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4111 if (h->root.type != bfd_link_hash_defined
4112 && h->root.type != bfd_link_hash_defweak)
4116 sec = h->root.u.def.section;
4119 if (sec != NULL && discarded_section (sec))
4120 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4122 elf64_alpha_howto_table + r_type, 0,
4125 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4126 rel->r_addend += sec->output_offset;
4132 /* Relocate an Alpha ELF section. */
4135 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4136 bfd *input_bfd, asection *input_section,
4137 bfd_byte *contents, Elf_Internal_Rela *relocs,
4138 Elf_Internal_Sym *local_syms,
4139 asection **local_sections)
4141 Elf_Internal_Shdr *symtab_hdr;
4142 Elf_Internal_Rela *rel;
4143 Elf_Internal_Rela *relend;
4144 asection *sgot, *srel, *srelgot;
4145 bfd *dynobj, *gotobj;
4146 bfd_vma gp, tp_base, dtp_base;
4147 struct alpha_elf_got_entry **local_got_entries;
4148 bfd_boolean ret_val;
4150 BFD_ASSERT (is_alpha_elf (input_bfd));
4152 /* Handle relocatable links with a smaller loop. */
4153 if (info->relocatable)
4154 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4155 input_section, contents, relocs,
4156 local_syms, local_sections);
4158 /* This is a final link. */
4162 symtab_hdr = &elf_symtab_hdr (input_bfd);
4164 dynobj = elf_hash_table (info)->dynobj;
4166 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
4170 if (input_section->flags & SEC_ALLOC)
4172 const char *section_name;
4173 section_name = (bfd_elf_string_from_elf_section
4174 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4175 _bfd_elf_single_rel_hdr (input_section)->sh_name));
4176 BFD_ASSERT(section_name != NULL);
4177 srel = bfd_get_linker_section (dynobj, section_name);
4182 /* Find the gp value for this input bfd. */
4183 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4186 sgot = alpha_elf_tdata (gotobj)->got;
4187 gp = _bfd_get_gp_value (gotobj);
4190 gp = (sgot->output_section->vma
4191 + sgot->output_offset
4193 _bfd_set_gp_value (gotobj, gp);
4202 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4204 if (elf_hash_table (info)->tls_sec != NULL)
4206 dtp_base = alpha_get_dtprel_base (info);
4207 tp_base = alpha_get_tprel_base (info);
4210 dtp_base = tp_base = 0;
4212 relend = relocs + input_section->reloc_count;
4213 for (rel = relocs; rel < relend; rel++)
4215 struct alpha_elf_link_hash_entry *h = NULL;
4216 struct alpha_elf_got_entry *gotent;
4217 bfd_reloc_status_type r;
4218 reloc_howto_type *howto;
4219 unsigned long r_symndx;
4220 Elf_Internal_Sym *sym = NULL;
4221 asection *sec = NULL;
4224 bfd_boolean dynamic_symbol_p;
4225 bfd_boolean unresolved_reloc = FALSE;
4226 bfd_boolean undef_weak_ref = FALSE;
4227 unsigned long r_type;
4229 r_type = ELF64_R_TYPE(rel->r_info);
4230 if (r_type >= R_ALPHA_max)
4232 (*_bfd_error_handler)
4233 (_("%B: unknown relocation type %d"),
4234 input_bfd, (int) r_type);
4235 bfd_set_error (bfd_error_bad_value);
4240 howto = elf64_alpha_howto_table + r_type;
4241 r_symndx = ELF64_R_SYM(rel->r_info);
4243 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4244 reloc to the STN_UNDEF (0) symbol so that they all match. */
4245 if (r_type == R_ALPHA_TLSLDM)
4246 r_symndx = STN_UNDEF;
4248 if (r_symndx < symtab_hdr->sh_info)
4251 sym = local_syms + r_symndx;
4252 sec = local_sections[r_symndx];
4254 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4256 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4257 this is hackery from relax_section. Force the value to
4258 be the tls module base. */
4259 if (r_symndx == STN_UNDEF
4260 && (r_type == R_ALPHA_TLSLDM
4261 || r_type == R_ALPHA_GOTTPREL
4262 || r_type == R_ALPHA_TPREL64
4263 || r_type == R_ALPHA_TPRELHI
4264 || r_type == R_ALPHA_TPRELLO
4265 || r_type == R_ALPHA_TPREL16))
4268 if (local_got_entries)
4269 gotent = local_got_entries[r_symndx];
4273 /* Need to adjust local GOT entries' addends for SEC_MERGE
4274 unless it has been done already. */
4275 if ((sec->flags & SEC_MERGE)
4276 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4277 && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4279 && !gotent->reloc_xlated)
4281 struct alpha_elf_got_entry *ent;
4283 for (ent = gotent; ent; ent = ent->next)
4285 ent->reloc_xlated = 1;
4286 if (ent->use_count == 0)
4290 _bfd_merged_section_offset (output_bfd, &msec,
4291 elf_section_data (sec)->
4293 sym->st_value + ent->addend);
4294 ent->addend -= sym->st_value;
4295 ent->addend += msec->output_section->vma
4296 + msec->output_offset
4297 - sec->output_section->vma
4298 - sec->output_offset;
4302 dynamic_symbol_p = FALSE;
4307 struct elf_link_hash_entry *hh;
4308 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4310 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4311 r_symndx, symtab_hdr, sym_hashes,
4313 unresolved_reloc, warned);
4319 && ! unresolved_reloc
4320 && hh->root.type == bfd_link_hash_undefweak)
4321 undef_weak_ref = TRUE;
4323 h = (struct alpha_elf_link_hash_entry *) hh;
4324 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4325 gotent = h->got_entries;
4328 if (sec != NULL && discarded_section (sec))
4329 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4330 rel, 1, relend, howto, 0, contents);
4332 addend = rel->r_addend;
4335 /* Search for the proper got entry. */
4336 for (; gotent ; gotent = gotent->next)
4337 if (gotent->gotobj == gotobj
4338 && gotent->reloc_type == r_type
4339 && gotent->addend == addend)
4344 case R_ALPHA_GPDISP:
4346 bfd_byte *p_ldah, *p_lda;
4348 BFD_ASSERT(gp != 0);
4350 value = (input_section->output_section->vma
4351 + input_section->output_offset
4354 p_ldah = contents + rel->r_offset;
4355 p_lda = p_ldah + rel->r_addend;
4357 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4362 case R_ALPHA_LITERAL:
4363 BFD_ASSERT(sgot != NULL);
4364 BFD_ASSERT(gp != 0);
4365 BFD_ASSERT(gotent != NULL);
4366 BFD_ASSERT(gotent->use_count >= 1);
4368 if (!gotent->reloc_done)
4370 gotent->reloc_done = 1;
4372 bfd_put_64 (output_bfd, value,
4373 sgot->contents + gotent->got_offset);
4375 /* If the symbol has been forced local, output a
4376 RELATIVE reloc, otherwise it will be handled in
4377 finish_dynamic_symbol. */
4378 if (info->shared && !dynamic_symbol_p && !undef_weak_ref)
4379 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4380 gotent->got_offset, 0,
4381 R_ALPHA_RELATIVE, value);
4384 value = (sgot->output_section->vma
4385 + sgot->output_offset
4386 + gotent->got_offset);
4390 case R_ALPHA_GPREL32:
4391 case R_ALPHA_GPREL16:
4392 case R_ALPHA_GPRELLOW:
4393 if (dynamic_symbol_p)
4395 (*_bfd_error_handler)
4396 (_("%B: gp-relative relocation against dynamic symbol %s"),
4397 input_bfd, h->root.root.root.string);
4400 BFD_ASSERT(gp != 0);
4404 case R_ALPHA_GPRELHIGH:
4405 if (dynamic_symbol_p)
4407 (*_bfd_error_handler)
4408 (_("%B: gp-relative relocation against dynamic symbol %s"),
4409 input_bfd, h->root.root.root.string);
4412 BFD_ASSERT(gp != 0);
4414 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4418 /* A call to a dynamic symbol is definitely out of range of
4419 the 16-bit displacement. Don't bother writing anything. */
4420 if (dynamic_symbol_p)
4425 /* The regular PC-relative stuff measures from the start of
4426 the instruction rather than the end. */
4430 case R_ALPHA_BRADDR:
4431 if (dynamic_symbol_p)
4433 (*_bfd_error_handler)
4434 (_("%B: pc-relative relocation against dynamic symbol %s"),
4435 input_bfd, h->root.root.root.string);
4438 /* The regular PC-relative stuff measures from the start of
4439 the instruction rather than the end. */
4448 /* The regular PC-relative stuff measures from the start of
4449 the instruction rather than the end. */
4452 /* The source and destination gp must be the same. Note that
4453 the source will always have an assigned gp, since we forced
4454 one in check_relocs, but that the destination may not, as
4455 it might not have had any relocations at all. Also take
4456 care not to crash if H is an undefined symbol. */
4457 if (h != NULL && sec != NULL
4458 && alpha_elf_tdata (sec->owner)->gotobj
4459 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4461 (*_bfd_error_handler)
4462 (_("%B: change in gp: BRSGP %s"),
4463 input_bfd, h->root.root.root.string);
4467 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4469 other = h->root.other;
4471 other = sym->st_other;
4472 switch (other & STO_ALPHA_STD_GPLOAD)
4474 case STO_ALPHA_NOPV:
4476 case STO_ALPHA_STD_GPLOAD:
4481 name = h->root.root.root.string;
4484 name = (bfd_elf_string_from_elf_section
4485 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4487 name = _("<unknown>");
4488 else if (name[0] == 0)
4489 name = bfd_section_name (input_bfd, sec);
4491 (*_bfd_error_handler)
4492 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4501 case R_ALPHA_REFLONG:
4502 case R_ALPHA_REFQUAD:
4503 case R_ALPHA_DTPREL64:
4504 case R_ALPHA_TPREL64:
4506 long dynindx, dyntype = r_type;
4509 /* Careful here to remember RELATIVE relocations for global
4510 variables for symbolic shared objects. */
4512 if (dynamic_symbol_p)
4514 BFD_ASSERT(h->root.dynindx != -1);
4515 dynindx = h->root.dynindx;
4517 addend = 0, value = 0;
4519 else if (r_type == R_ALPHA_DTPREL64)
4521 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4525 else if (r_type == R_ALPHA_TPREL64)
4527 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4528 if (!info->shared || info->pie)
4534 dynaddend = value - dtp_base;
4536 else if (info->shared
4537 && r_symndx != STN_UNDEF
4538 && (input_section->flags & SEC_ALLOC)
4540 && !(unresolved_reloc
4541 && (_bfd_elf_section_offset (output_bfd, info,
4546 if (r_type == R_ALPHA_REFLONG)
4548 (*_bfd_error_handler)
4549 (_("%B: unhandled dynamic relocation against %s"),
4551 h->root.root.root.string);
4555 dyntype = R_ALPHA_RELATIVE;
4561 if (input_section->flags & SEC_ALLOC)
4562 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4563 srel, rel->r_offset, dynindx,
4564 dyntype, dynaddend);
4568 case R_ALPHA_SREL16:
4569 case R_ALPHA_SREL32:
4570 case R_ALPHA_SREL64:
4571 if (dynamic_symbol_p)
4573 (*_bfd_error_handler)
4574 (_("%B: pc-relative relocation against dynamic symbol %s"),
4575 input_bfd, h->root.root.root.string);
4578 else if ((info->shared || info->pie) && undef_weak_ref)
4580 (*_bfd_error_handler)
4581 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4582 input_bfd, h->root.root.root.string);
4587 /* ??? .eh_frame references to discarded sections will be smashed
4588 to relocations against SHN_UNDEF. The .eh_frame format allows
4589 NULL to be encoded as 0 in any format, so this works here. */
4590 if (r_symndx == STN_UNDEF
4591 || (unresolved_reloc
4592 && _bfd_elf_section_offset (output_bfd, info,
4594 rel->r_offset) == (bfd_vma) -1))
4595 howto = (elf64_alpha_howto_table
4596 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4599 case R_ALPHA_TLSLDM:
4600 /* Ignore the symbol for the relocation. The result is always
4601 the current module. */
4602 dynamic_symbol_p = 0;
4606 if (!gotent->reloc_done)
4608 gotent->reloc_done = 1;
4610 /* Note that the module index for the main program is 1. */
4611 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4612 sgot->contents + gotent->got_offset);
4614 /* If the symbol has been forced local, output a
4615 DTPMOD64 reloc, otherwise it will be handled in
4616 finish_dynamic_symbol. */
4617 if (info->shared && !dynamic_symbol_p)
4618 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4619 gotent->got_offset, 0,
4620 R_ALPHA_DTPMOD64, 0);
4622 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4626 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4629 bfd_put_64 (output_bfd, value,
4630 sgot->contents + gotent->got_offset + 8);
4633 value = (sgot->output_section->vma
4634 + sgot->output_offset
4635 + gotent->got_offset);
4639 case R_ALPHA_DTPRELHI:
4640 case R_ALPHA_DTPRELLO:
4641 case R_ALPHA_DTPREL16:
4642 if (dynamic_symbol_p)
4644 (*_bfd_error_handler)
4645 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4646 input_bfd, h->root.root.root.string);
4649 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4651 if (r_type == R_ALPHA_DTPRELHI)
4652 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4655 case R_ALPHA_TPRELHI:
4656 case R_ALPHA_TPRELLO:
4657 case R_ALPHA_TPREL16:
4658 if (info->shared && !info->pie)
4660 (*_bfd_error_handler)
4661 (_("%B: TLS local exec code cannot be linked into shared objects"),
4665 else if (dynamic_symbol_p)
4667 (*_bfd_error_handler)
4668 (_("%B: tp-relative relocation against dynamic symbol %s"),
4669 input_bfd, h->root.root.root.string);
4672 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4674 if (r_type == R_ALPHA_TPRELHI)
4675 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4678 case R_ALPHA_GOTDTPREL:
4679 case R_ALPHA_GOTTPREL:
4680 BFD_ASSERT(sgot != NULL);
4681 BFD_ASSERT(gp != 0);
4682 BFD_ASSERT(gotent != NULL);
4683 BFD_ASSERT(gotent->use_count >= 1);
4685 if (!gotent->reloc_done)
4687 gotent->reloc_done = 1;
4689 if (dynamic_symbol_p)
4693 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4694 if (r_type == R_ALPHA_GOTDTPREL)
4696 else if (!info->shared)
4700 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4701 gotent->got_offset, 0,
4707 bfd_put_64 (output_bfd, value,
4708 sgot->contents + gotent->got_offset);
4711 value = (sgot->output_section->vma
4712 + sgot->output_offset
4713 + gotent->got_offset);
4719 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4720 contents, rel->r_offset, value, 0);
4729 case bfd_reloc_overflow:
4733 /* Don't warn if the overflow is due to pc relative reloc
4734 against discarded section. Section optimization code should
4737 if (r_symndx < symtab_hdr->sh_info
4738 && sec != NULL && howto->pc_relative
4739 && discarded_section (sec))
4746 name = (bfd_elf_string_from_elf_section
4747 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4751 name = bfd_section_name (input_bfd, sec);
4753 if (! ((*info->callbacks->reloc_overflow)
4754 (info, (h ? &h->root.root : NULL), name, howto->name,
4755 (bfd_vma) 0, input_bfd, input_section,
4762 case bfd_reloc_outofrange:
4770 /* Finish up dynamic symbol handling. We set the contents of various
4771 dynamic sections here. */
4774 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4775 struct elf_link_hash_entry *h,
4776 Elf_Internal_Sym *sym)
4778 struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4779 bfd *dynobj = elf_hash_table(info)->dynobj;
4783 /* Fill in the .plt entry for this symbol. */
4784 asection *splt, *sgot, *srel;
4785 Elf_Internal_Rela outrel;
4787 bfd_vma got_addr, plt_addr;
4789 struct alpha_elf_got_entry *gotent;
4791 BFD_ASSERT (h->dynindx != -1);
4793 splt = bfd_get_linker_section (dynobj, ".plt");
4794 BFD_ASSERT (splt != NULL);
4795 srel = bfd_get_linker_section (dynobj, ".rela.plt");
4796 BFD_ASSERT (srel != NULL);
4798 for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4799 if (gotent->reloc_type == R_ALPHA_LITERAL
4800 && gotent->use_count > 0)
4805 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4806 BFD_ASSERT (sgot != NULL);
4808 BFD_ASSERT (gotent->got_offset != -1);
4809 BFD_ASSERT (gotent->plt_offset != -1);
4811 got_addr = (sgot->output_section->vma
4812 + sgot->output_offset
4813 + gotent->got_offset);
4814 plt_addr = (splt->output_section->vma
4815 + splt->output_offset
4816 + gotent->plt_offset);
4818 plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4820 /* Fill in the entry in the procedure linkage table. */
4821 if (elf64_alpha_use_secureplt)
4823 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4824 insn = INSN_AD (INSN_BR, 31, disp);
4825 bfd_put_32 (output_bfd, insn,
4826 splt->contents + gotent->plt_offset);
4828 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4829 / NEW_PLT_ENTRY_SIZE);
4833 disp = -(gotent->plt_offset + 4);
4834 insn = INSN_AD (INSN_BR, 28, disp);
4835 bfd_put_32 (output_bfd, insn,
4836 splt->contents + gotent->plt_offset);
4837 bfd_put_32 (output_bfd, INSN_UNOP,
4838 splt->contents + gotent->plt_offset + 4);
4839 bfd_put_32 (output_bfd, INSN_UNOP,
4840 splt->contents + gotent->plt_offset + 8);
4842 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4843 / OLD_PLT_ENTRY_SIZE);
4846 /* Fill in the entry in the .rela.plt section. */
4847 outrel.r_offset = got_addr;
4848 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4849 outrel.r_addend = 0;
4851 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4852 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4854 /* Fill in the entry in the .got. */
4855 bfd_put_64 (output_bfd, plt_addr,
4856 sgot->contents + gotent->got_offset);
4859 else if (alpha_elf_dynamic_symbol_p (h, info))
4861 /* Fill in the dynamic relocations for this symbol's .got entries. */
4863 struct alpha_elf_got_entry *gotent;
4865 srel = bfd_get_linker_section (dynobj, ".rela.got");
4866 BFD_ASSERT (srel != NULL);
4868 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4870 gotent = gotent->next)
4875 if (gotent->use_count == 0)
4878 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4880 r_type = gotent->reloc_type;
4883 case R_ALPHA_LITERAL:
4884 r_type = R_ALPHA_GLOB_DAT;
4887 r_type = R_ALPHA_DTPMOD64;
4889 case R_ALPHA_GOTDTPREL:
4890 r_type = R_ALPHA_DTPREL64;
4892 case R_ALPHA_GOTTPREL:
4893 r_type = R_ALPHA_TPREL64;
4895 case R_ALPHA_TLSLDM:
4900 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4901 gotent->got_offset, h->dynindx,
4902 r_type, gotent->addend);
4904 if (gotent->reloc_type == R_ALPHA_TLSGD)
4905 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4906 gotent->got_offset + 8, h->dynindx,
4907 R_ALPHA_DTPREL64, gotent->addend);
4911 /* Mark some specially defined symbols as absolute. */
4912 if (h == elf_hash_table (info)->hdynamic
4913 || h == elf_hash_table (info)->hgot
4914 || h == elf_hash_table (info)->hplt)
4915 sym->st_shndx = SHN_ABS;
4920 /* Finish up the dynamic sections. */
4923 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
4924 struct bfd_link_info *info)
4929 dynobj = elf_hash_table (info)->dynobj;
4930 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4932 if (elf_hash_table (info)->dynamic_sections_created)
4934 asection *splt, *sgotplt, *srelaplt;
4935 Elf64_External_Dyn *dyncon, *dynconend;
4936 bfd_vma plt_vma, gotplt_vma;
4938 splt = bfd_get_linker_section (dynobj, ".plt");
4939 srelaplt = bfd_get_linker_section (output_bfd, ".rela.plt");
4940 BFD_ASSERT (splt != NULL && sdyn != NULL);
4942 plt_vma = splt->output_section->vma + splt->output_offset;
4945 if (elf64_alpha_use_secureplt)
4947 sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
4948 BFD_ASSERT (sgotplt != NULL);
4949 if (sgotplt->size > 0)
4950 gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
4953 dyncon = (Elf64_External_Dyn *) sdyn->contents;
4954 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4955 for (; dyncon < dynconend; dyncon++)
4957 Elf_Internal_Dyn dyn;
4959 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4965 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
4968 dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
4971 dyn.d_un.d_ptr = srelaplt ? srelaplt->vma : 0;
4975 /* My interpretation of the TIS v1.1 ELF document indicates
4976 that RELASZ should not include JMPREL. This is not what
4977 the rest of the BFD does. It is, however, what the
4978 glibc ld.so wants. Do this fixup here until we found
4979 out who is right. */
4981 dyn.d_un.d_val -= srelaplt->size;
4985 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
4988 /* Initialize the plt header. */
4994 if (elf64_alpha_use_secureplt)
4996 ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
4998 insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
4999 bfd_put_32 (output_bfd, insn, splt->contents);
5001 insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
5002 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5004 insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
5005 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5007 insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5008 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5010 insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5011 bfd_put_32 (output_bfd, insn, splt->contents + 16);
5013 insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5014 bfd_put_32 (output_bfd, insn, splt->contents + 20);
5016 insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5017 bfd_put_32 (output_bfd, insn, splt->contents + 24);
5019 insn = INSN_AB (INSN_JMP, 31, 27);
5020 bfd_put_32 (output_bfd, insn, splt->contents + 28);
5022 insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5023 bfd_put_32 (output_bfd, insn, splt->contents + 32);
5027 insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */
5028 bfd_put_32 (output_bfd, insn, splt->contents);
5030 insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5031 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5034 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5036 insn = INSN_AB (INSN_JMP, 27, 27);
5037 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5039 /* The next two words will be filled in by ld.so. */
5040 bfd_put_64 (output_bfd, 0, splt->contents + 16);
5041 bfd_put_64 (output_bfd, 0, splt->contents + 24);
5044 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5051 /* We need to use a special link routine to handle the .mdebug section.
5052 We need to merge all instances of these sections together, not write
5053 them all out sequentially. */
5056 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5059 struct bfd_link_order *p;
5060 asection *mdebug_sec;
5061 struct ecoff_debug_info debug;
5062 const struct ecoff_debug_swap *swap
5063 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5064 HDRR *symhdr = &debug.symbolic_header;
5065 void * mdebug_handle = NULL;
5066 struct alpha_elf_link_hash_table * htab;
5068 htab = alpha_elf_hash_table (info);
5072 /* Go through the sections and collect the mdebug information. */
5074 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5076 if (strcmp (o->name, ".mdebug") == 0)
5078 struct extsym_info einfo;
5080 /* We have found the .mdebug section in the output file.
5081 Look through all the link_orders comprising it and merge
5082 the information together. */
5083 symhdr->magic = swap->sym_magic;
5084 /* FIXME: What should the version stamp be? */
5086 symhdr->ilineMax = 0;
5090 symhdr->isymMax = 0;
5091 symhdr->ioptMax = 0;
5092 symhdr->iauxMax = 0;
5094 symhdr->issExtMax = 0;
5097 symhdr->iextMax = 0;
5099 /* We accumulate the debugging information itself in the
5100 debug_info structure. */
5102 debug.external_dnr = NULL;
5103 debug.external_pdr = NULL;
5104 debug.external_sym = NULL;
5105 debug.external_opt = NULL;
5106 debug.external_aux = NULL;
5108 debug.ssext = debug.ssext_end = NULL;
5109 debug.external_fdr = NULL;
5110 debug.external_rfd = NULL;
5111 debug.external_ext = debug.external_ext_end = NULL;
5113 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5114 if (mdebug_handle == NULL)
5123 static const char * const name[] =
5125 ".text", ".init", ".fini", ".data",
5126 ".rodata", ".sdata", ".sbss", ".bss"
5128 static const int sc[] = { scText, scInit, scFini, scData,
5129 scRData, scSData, scSBss, scBss };
5132 esym.cobol_main = 0;
5136 esym.asym.iss = issNil;
5137 esym.asym.st = stLocal;
5138 esym.asym.reserved = 0;
5139 esym.asym.index = indexNil;
5140 for (i = 0; i < 8; i++)
5142 esym.asym.sc = sc[i];
5143 s = bfd_get_section_by_name (abfd, name[i]);
5146 esym.asym.value = s->vma;
5147 last = s->vma + s->size;
5150 esym.asym.value = last;
5152 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5158 for (p = o->map_head.link_order;
5159 p != (struct bfd_link_order *) NULL;
5162 asection *input_section;
5164 const struct ecoff_debug_swap *input_swap;
5165 struct ecoff_debug_info input_debug;
5169 if (p->type != bfd_indirect_link_order)
5171 if (p->type == bfd_data_link_order)
5176 input_section = p->u.indirect.section;
5177 input_bfd = input_section->owner;
5179 if (! is_alpha_elf (input_bfd))
5180 /* I don't know what a non ALPHA ELF bfd would be
5181 doing with a .mdebug section, but I don't really
5182 want to deal with it. */
5185 input_swap = (get_elf_backend_data (input_bfd)
5186 ->elf_backend_ecoff_debug_swap);
5188 BFD_ASSERT (p->size == input_section->size);
5190 /* The ECOFF linking code expects that we have already
5191 read in the debugging information and set up an
5192 ecoff_debug_info structure, so we do that now. */
5193 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5197 if (! (bfd_ecoff_debug_accumulate
5198 (mdebug_handle, abfd, &debug, swap, input_bfd,
5199 &input_debug, input_swap, info)))
5202 /* Loop through the external symbols. For each one with
5203 interesting information, try to find the symbol in
5204 the linker global hash table and save the information
5205 for the output external symbols. */
5206 eraw_src = (char *) input_debug.external_ext;
5207 eraw_end = (eraw_src
5208 + (input_debug.symbolic_header.iextMax
5209 * input_swap->external_ext_size));
5211 eraw_src < eraw_end;
5212 eraw_src += input_swap->external_ext_size)
5216 struct alpha_elf_link_hash_entry *h;
5218 (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5219 if (ext.asym.sc == scNil
5220 || ext.asym.sc == scUndefined
5221 || ext.asym.sc == scSUndefined)
5224 name = input_debug.ssext + ext.asym.iss;
5225 h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5226 if (h == NULL || h->esym.ifd != -2)
5232 < input_debug.symbolic_header.ifdMax);
5233 ext.ifd = input_debug.ifdmap[ext.ifd];
5239 /* Free up the information we just read. */
5240 free (input_debug.line);
5241 free (input_debug.external_dnr);
5242 free (input_debug.external_pdr);
5243 free (input_debug.external_sym);
5244 free (input_debug.external_opt);
5245 free (input_debug.external_aux);
5246 free (input_debug.ss);
5247 free (input_debug.ssext);
5248 free (input_debug.external_fdr);
5249 free (input_debug.external_rfd);
5250 free (input_debug.external_ext);
5252 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5253 elf_link_input_bfd ignores this section. */
5254 input_section->flags &=~ SEC_HAS_CONTENTS;
5257 /* Build the external symbol information. */
5260 einfo.debug = &debug;
5262 einfo.failed = FALSE;
5263 elf_link_hash_traverse (elf_hash_table (info),
5264 elf64_alpha_output_extsym,
5269 /* Set the size of the .mdebug section. */
5270 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5272 /* Skip this section later on (I don't think this currently
5273 matters, but someday it might). */
5274 o->map_head.link_order = (struct bfd_link_order *) NULL;
5280 /* Invoke the regular ELF backend linker to do all the work. */
5281 if (! bfd_elf_final_link (abfd, info))
5284 /* Now write out the computed sections. */
5286 /* The .got subsections... */
5288 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5289 for (i = htab->got_list;
5291 i = alpha_elf_tdata(i)->got_link_next)
5295 /* elf_bfd_final_link already did everything in dynobj. */
5299 sgot = alpha_elf_tdata(i)->got;
5300 if (! bfd_set_section_contents (abfd, sgot->output_section,
5302 (file_ptr) sgot->output_offset,
5308 if (mdebug_sec != (asection *) NULL)
5310 BFD_ASSERT (abfd->output_has_begun);
5311 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5313 mdebug_sec->filepos))
5316 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5322 static enum elf_reloc_type_class
5323 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5324 const asection *rel_sec ATTRIBUTE_UNUSED,
5325 const Elf_Internal_Rela *rela)
5327 switch ((int) ELF64_R_TYPE (rela->r_info))
5329 case R_ALPHA_RELATIVE:
5330 return reloc_class_relative;
5331 case R_ALPHA_JMP_SLOT:
5332 return reloc_class_plt;
5334 return reloc_class_copy;
5336 return reloc_class_normal;
5340 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5342 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5343 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5344 { NULL, 0, 0, 0, 0 }
5347 /* ECOFF swapping routines. These are used when dealing with the
5348 .mdebug section, which is in the ECOFF debugging format. Copied
5349 from elf32-mips.c. */
5350 static const struct ecoff_debug_swap
5351 elf64_alpha_ecoff_debug_swap =
5353 /* Symbol table magic number. */
5355 /* Alignment of debugging information. E.g., 4. */
5357 /* Sizes of external symbolic information. */
5358 sizeof (struct hdr_ext),
5359 sizeof (struct dnr_ext),
5360 sizeof (struct pdr_ext),
5361 sizeof (struct sym_ext),
5362 sizeof (struct opt_ext),
5363 sizeof (struct fdr_ext),
5364 sizeof (struct rfd_ext),
5365 sizeof (struct ext_ext),
5366 /* Functions to swap in external symbolic data. */
5375 _bfd_ecoff_swap_tir_in,
5376 _bfd_ecoff_swap_rndx_in,
5377 /* Functions to swap out external symbolic data. */
5386 _bfd_ecoff_swap_tir_out,
5387 _bfd_ecoff_swap_rndx_out,
5388 /* Function to read in symbolic data. */
5389 elf64_alpha_read_ecoff_info
5392 /* Use a non-standard hash bucket size of 8. */
5394 static const struct elf_size_info alpha_elf_size_info =
5396 sizeof (Elf64_External_Ehdr),
5397 sizeof (Elf64_External_Phdr),
5398 sizeof (Elf64_External_Shdr),
5399 sizeof (Elf64_External_Rel),
5400 sizeof (Elf64_External_Rela),
5401 sizeof (Elf64_External_Sym),
5402 sizeof (Elf64_External_Dyn),
5403 sizeof (Elf_External_Note),
5407 ELFCLASS64, EV_CURRENT,
5408 bfd_elf64_write_out_phdrs,
5409 bfd_elf64_write_shdrs_and_ehdr,
5410 bfd_elf64_checksum_contents,
5411 bfd_elf64_write_relocs,
5412 bfd_elf64_swap_symbol_in,
5413 bfd_elf64_swap_symbol_out,
5414 bfd_elf64_slurp_reloc_table,
5415 bfd_elf64_slurp_symbol_table,
5416 bfd_elf64_swap_dyn_in,
5417 bfd_elf64_swap_dyn_out,
5418 bfd_elf64_swap_reloc_in,
5419 bfd_elf64_swap_reloc_out,
5420 bfd_elf64_swap_reloca_in,
5421 bfd_elf64_swap_reloca_out
5424 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5425 #define TARGET_LITTLE_NAME "elf64-alpha"
5426 #define ELF_ARCH bfd_arch_alpha
5427 #define ELF_TARGET_ID ALPHA_ELF_DATA
5428 #define ELF_MACHINE_CODE EM_ALPHA
5429 #define ELF_MAXPAGESIZE 0x10000
5430 #define ELF_COMMONPAGESIZE 0x2000
5432 #define bfd_elf64_bfd_link_hash_table_create \
5433 elf64_alpha_bfd_link_hash_table_create
5435 #define bfd_elf64_bfd_reloc_type_lookup \
5436 elf64_alpha_bfd_reloc_type_lookup
5437 #define bfd_elf64_bfd_reloc_name_lookup \
5438 elf64_alpha_bfd_reloc_name_lookup
5439 #define elf_info_to_howto \
5440 elf64_alpha_info_to_howto
5442 #define bfd_elf64_mkobject \
5443 elf64_alpha_mkobject
5444 #define elf_backend_object_p \
5445 elf64_alpha_object_p
5447 #define elf_backend_section_from_shdr \
5448 elf64_alpha_section_from_shdr
5449 #define elf_backend_section_flags \
5450 elf64_alpha_section_flags
5451 #define elf_backend_fake_sections \
5452 elf64_alpha_fake_sections
5454 #define bfd_elf64_bfd_is_local_label_name \
5455 elf64_alpha_is_local_label_name
5456 #define bfd_elf64_find_nearest_line \
5457 elf64_alpha_find_nearest_line
5458 #define bfd_elf64_bfd_relax_section \
5459 elf64_alpha_relax_section
5461 #define elf_backend_add_symbol_hook \
5462 elf64_alpha_add_symbol_hook
5463 #define elf_backend_relocs_compatible \
5464 _bfd_elf_relocs_compatible
5465 #define elf_backend_check_relocs \
5466 elf64_alpha_check_relocs
5467 #define elf_backend_create_dynamic_sections \
5468 elf64_alpha_create_dynamic_sections
5469 #define elf_backend_adjust_dynamic_symbol \
5470 elf64_alpha_adjust_dynamic_symbol
5471 #define elf_backend_merge_symbol_attribute \
5472 elf64_alpha_merge_symbol_attribute
5473 #define elf_backend_copy_indirect_symbol \
5474 elf64_alpha_copy_indirect_symbol
5475 #define elf_backend_always_size_sections \
5476 elf64_alpha_always_size_sections
5477 #define elf_backend_size_dynamic_sections \
5478 elf64_alpha_size_dynamic_sections
5479 #define elf_backend_omit_section_dynsym \
5480 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5481 #define elf_backend_relocate_section \
5482 elf64_alpha_relocate_section
5483 #define elf_backend_finish_dynamic_symbol \
5484 elf64_alpha_finish_dynamic_symbol
5485 #define elf_backend_finish_dynamic_sections \
5486 elf64_alpha_finish_dynamic_sections
5487 #define bfd_elf64_bfd_final_link \
5488 elf64_alpha_final_link
5489 #define elf_backend_reloc_type_class \
5490 elf64_alpha_reloc_type_class
5492 #define elf_backend_can_gc_sections 1
5493 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5494 #define elf_backend_gc_sweep_hook elf64_alpha_gc_sweep_hook
5496 #define elf_backend_ecoff_debug_swap \
5497 &elf64_alpha_ecoff_debug_swap
5499 #define elf_backend_size_info \
5502 #define elf_backend_special_sections \
5503 elf64_alpha_special_sections
5505 /* A few constants that determine how the .plt section is set up. */
5506 #define elf_backend_want_got_plt 0
5507 #define elf_backend_plt_readonly 0
5508 #define elf_backend_want_plt_sym 1
5509 #define elf_backend_got_header_size 0
5511 #include "elf64-target.h"
5513 /* FreeBSD support. */
5515 #undef TARGET_LITTLE_SYM
5516 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5517 #undef TARGET_LITTLE_NAME
5518 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5520 #define ELF_OSABI ELFOSABI_FREEBSD
5522 /* The kernel recognizes executables as valid only if they carry a
5523 "FreeBSD" label in the ELF header. So we put this label on all
5524 executables and (for simplicity) also all other object files. */
5527 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5528 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5530 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5532 i_ehdrp = elf_elfheader (abfd);
5534 /* Put an ABI label supported by FreeBSD >= 4.1. */
5535 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5536 #ifdef OLD_FREEBSD_ABI_LABEL
5537 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5538 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5542 #undef elf_backend_post_process_headers
5543 #define elf_backend_post_process_headers \
5544 elf64_alpha_fbsd_post_process_headers
5547 #define elf64_bed elf64_alpha_fbsd_bed
5549 #include "elf64-target.h"