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
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 *, PTR)) (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 /* We have some private fields hanging off of the elf_tdata structure. */
304 struct alpha_elf_obj_tdata
306 struct elf_obj_tdata root;
308 /* For every input file, these are the got entries for that object's
310 struct alpha_elf_got_entry ** local_got_entries;
312 /* For every input file, this is the object that owns the got that
313 this input file uses. */
316 /* For every got, this is a linked list through the objects using this got */
317 bfd *in_got_link_next;
319 /* For every got, this is a link to the next got subsegment. */
322 /* For every got, this is the section. */
325 /* For every got, this is it's total number of words. */
328 /* For every got, this is the sum of the number of words required
329 to hold all of the member object's local got. */
333 #define alpha_elf_tdata(abfd) \
334 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
336 #define is_alpha_elf(bfd) \
337 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
338 && elf_tdata (bfd) != NULL \
339 && elf_object_id (bfd) == ALPHA_ELF_DATA)
342 elf64_alpha_mkobject (bfd *abfd)
344 return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
349 elf64_alpha_object_p (bfd *abfd)
351 /* Set the right machine number for an Alpha ELF file. */
352 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
355 /* A relocation function which doesn't do anything. */
357 static bfd_reloc_status_type
358 elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
359 asymbol *sym ATTRIBUTE_UNUSED,
360 PTR data ATTRIBUTE_UNUSED, asection *sec,
361 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
364 reloc->address += sec->output_offset;
368 /* A relocation function used for an unsupported reloc. */
370 static bfd_reloc_status_type
371 elf64_alpha_reloc_bad (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
372 asymbol *sym ATTRIBUTE_UNUSED,
373 PTR data ATTRIBUTE_UNUSED, asection *sec,
374 bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
377 reloc->address += sec->output_offset;
378 return bfd_reloc_notsupported;
381 /* Do the work of the GPDISP relocation. */
383 static bfd_reloc_status_type
384 elf64_alpha_do_reloc_gpdisp (bfd *abfd, bfd_vma gpdisp, bfd_byte *p_ldah,
387 bfd_reloc_status_type ret = bfd_reloc_ok;
389 unsigned long i_ldah, i_lda;
391 i_ldah = bfd_get_32 (abfd, p_ldah);
392 i_lda = bfd_get_32 (abfd, p_lda);
394 /* Complain if the instructions are not correct. */
395 if (((i_ldah >> 26) & 0x3f) != 0x09
396 || ((i_lda >> 26) & 0x3f) != 0x08)
397 ret = bfd_reloc_dangerous;
399 /* Extract the user-supplied offset, mirroring the sign extensions
400 that the instructions perform. */
401 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
402 addend = (addend ^ 0x80008000) - 0x80008000;
406 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
407 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
408 ret = bfd_reloc_overflow;
410 /* compensate for the sign extension again. */
411 i_ldah = ((i_ldah & 0xffff0000)
412 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
413 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
415 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
416 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
421 /* The special function for the GPDISP reloc. */
423 static bfd_reloc_status_type
424 elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry,
425 asymbol *sym ATTRIBUTE_UNUSED, PTR data,
426 asection *input_section, bfd *output_bfd,
429 bfd_reloc_status_type ret;
430 bfd_vma gp, relocation;
431 bfd_vma high_address;
432 bfd_byte *p_ldah, *p_lda;
434 /* Don't do anything if we're not doing a final link. */
437 reloc_entry->address += input_section->output_offset;
441 high_address = bfd_get_section_limit (abfd, input_section);
442 if (reloc_entry->address > high_address
443 || reloc_entry->address + reloc_entry->addend > high_address)
444 return bfd_reloc_outofrange;
446 /* The gp used in the portion of the output object to which this
447 input object belongs is cached on the input bfd. */
448 gp = _bfd_get_gp_value (abfd);
450 relocation = (input_section->output_section->vma
451 + input_section->output_offset
452 + reloc_entry->address);
454 p_ldah = (bfd_byte *) data + reloc_entry->address;
455 p_lda = p_ldah + reloc_entry->addend;
457 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
459 /* Complain if the instructions are not correct. */
460 if (ret == bfd_reloc_dangerous)
461 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
466 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
467 from smaller values. Start with zero, widen, *then* decrement. */
468 #define MINUS_ONE (((bfd_vma)0) - 1)
471 #define SKIP_HOWTO(N) \
472 HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
474 static reloc_howto_type elf64_alpha_howto_table[] =
476 HOWTO (R_ALPHA_NONE, /* type */
478 0, /* size (0 = byte, 1 = short, 2 = long) */
480 TRUE, /* pc_relative */
482 complain_overflow_dont, /* complain_on_overflow */
483 elf64_alpha_reloc_nil, /* special_function */
485 FALSE, /* partial_inplace */
488 TRUE), /* pcrel_offset */
490 /* A 32 bit reference to a symbol. */
491 HOWTO (R_ALPHA_REFLONG, /* type */
493 2, /* size (0 = byte, 1 = short, 2 = long) */
495 FALSE, /* pc_relative */
497 complain_overflow_bitfield, /* complain_on_overflow */
498 bfd_elf_generic_reloc, /* special_function */
499 "REFLONG", /* name */
500 FALSE, /* partial_inplace */
501 0xffffffff, /* src_mask */
502 0xffffffff, /* dst_mask */
503 FALSE), /* pcrel_offset */
505 /* A 64 bit reference to a symbol. */
506 HOWTO (R_ALPHA_REFQUAD, /* type */
508 4, /* size (0 = byte, 1 = short, 2 = long) */
510 FALSE, /* pc_relative */
512 complain_overflow_bitfield, /* complain_on_overflow */
513 bfd_elf_generic_reloc, /* special_function */
514 "REFQUAD", /* name */
515 FALSE, /* partial_inplace */
516 MINUS_ONE, /* src_mask */
517 MINUS_ONE, /* dst_mask */
518 FALSE), /* pcrel_offset */
520 /* A 32 bit GP relative offset. This is just like REFLONG except
521 that when the value is used the value of the gp register will be
523 HOWTO (R_ALPHA_GPREL32, /* type */
525 2, /* size (0 = byte, 1 = short, 2 = long) */
527 FALSE, /* pc_relative */
529 complain_overflow_bitfield, /* complain_on_overflow */
530 bfd_elf_generic_reloc, /* special_function */
531 "GPREL32", /* name */
532 FALSE, /* partial_inplace */
533 0xffffffff, /* src_mask */
534 0xffffffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
537 /* Used for an instruction that refers to memory off the GP register. */
538 HOWTO (R_ALPHA_LITERAL, /* type */
540 1, /* size (0 = byte, 1 = short, 2 = long) */
542 FALSE, /* pc_relative */
544 complain_overflow_signed, /* complain_on_overflow */
545 bfd_elf_generic_reloc, /* special_function */
546 "ELF_LITERAL", /* name */
547 FALSE, /* partial_inplace */
548 0xffff, /* src_mask */
549 0xffff, /* dst_mask */
550 FALSE), /* pcrel_offset */
552 /* This reloc only appears immediately following an ELF_LITERAL reloc.
553 It identifies a use of the literal. The symbol index is special:
554 1 means the literal address is in the base register of a memory
555 format instruction; 2 means the literal address is in the byte
556 offset register of a byte-manipulation instruction; 3 means the
557 literal address is in the target register of a jsr instruction.
558 This does not actually do any relocation. */
559 HOWTO (R_ALPHA_LITUSE, /* type */
561 1, /* size (0 = byte, 1 = short, 2 = long) */
563 FALSE, /* pc_relative */
565 complain_overflow_dont, /* complain_on_overflow */
566 elf64_alpha_reloc_nil, /* special_function */
568 FALSE, /* partial_inplace */
571 FALSE), /* pcrel_offset */
573 /* Load the gp register. This is always used for a ldah instruction
574 which loads the upper 16 bits of the gp register. The symbol
575 index of the GPDISP instruction is an offset in bytes to the lda
576 instruction that loads the lower 16 bits. The value to use for
577 the relocation is the difference between the GP value and the
578 current location; the load will always be done against a register
579 holding the current address.
581 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
582 any offset is present in the instructions, it is an offset from
583 the register to the ldah instruction. This lets us avoid any
584 stupid hackery like inventing a gp value to do partial relocation
585 against. Also unlike ECOFF, we do the whole relocation off of
586 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
587 space consuming bit, that, since all the information was present
588 in the GPDISP_HI16 reloc. */
589 HOWTO (R_ALPHA_GPDISP, /* type */
591 2, /* size (0 = byte, 1 = short, 2 = long) */
593 FALSE, /* pc_relative */
595 complain_overflow_dont, /* complain_on_overflow */
596 elf64_alpha_reloc_gpdisp, /* special_function */
598 FALSE, /* partial_inplace */
599 0xffff, /* src_mask */
600 0xffff, /* dst_mask */
601 TRUE), /* pcrel_offset */
603 /* A 21 bit branch. */
604 HOWTO (R_ALPHA_BRADDR, /* type */
606 2, /* size (0 = byte, 1 = short, 2 = long) */
608 TRUE, /* pc_relative */
610 complain_overflow_signed, /* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
613 FALSE, /* partial_inplace */
614 0x1fffff, /* src_mask */
615 0x1fffff, /* dst_mask */
616 TRUE), /* pcrel_offset */
618 /* A hint for a jump to a register. */
619 HOWTO (R_ALPHA_HINT, /* type */
621 1, /* size (0 = byte, 1 = short, 2 = long) */
623 TRUE, /* pc_relative */
625 complain_overflow_dont, /* complain_on_overflow */
626 bfd_elf_generic_reloc, /* special_function */
628 FALSE, /* partial_inplace */
629 0x3fff, /* src_mask */
630 0x3fff, /* dst_mask */
631 TRUE), /* pcrel_offset */
633 /* 16 bit PC relative offset. */
634 HOWTO (R_ALPHA_SREL16, /* type */
636 1, /* size (0 = byte, 1 = short, 2 = long) */
638 TRUE, /* pc_relative */
640 complain_overflow_signed, /* complain_on_overflow */
641 bfd_elf_generic_reloc, /* special_function */
643 FALSE, /* partial_inplace */
644 0xffff, /* src_mask */
645 0xffff, /* dst_mask */
646 TRUE), /* pcrel_offset */
648 /* 32 bit PC relative offset. */
649 HOWTO (R_ALPHA_SREL32, /* type */
651 2, /* size (0 = byte, 1 = short, 2 = long) */
653 TRUE, /* pc_relative */
655 complain_overflow_signed, /* complain_on_overflow */
656 bfd_elf_generic_reloc, /* special_function */
658 FALSE, /* partial_inplace */
659 0xffffffff, /* src_mask */
660 0xffffffff, /* dst_mask */
661 TRUE), /* pcrel_offset */
663 /* A 64 bit PC relative offset. */
664 HOWTO (R_ALPHA_SREL64, /* type */
666 4, /* size (0 = byte, 1 = short, 2 = long) */
668 TRUE, /* pc_relative */
670 complain_overflow_signed, /* complain_on_overflow */
671 bfd_elf_generic_reloc, /* special_function */
673 FALSE, /* partial_inplace */
674 MINUS_ONE, /* src_mask */
675 MINUS_ONE, /* dst_mask */
676 TRUE), /* pcrel_offset */
678 /* Skip 12 - 16; deprecated ECOFF relocs. */
685 /* The high 16 bits of the displacement from GP to the target. */
686 HOWTO (R_ALPHA_GPRELHIGH,
688 1, /* size (0 = byte, 1 = short, 2 = long) */
690 FALSE, /* pc_relative */
692 complain_overflow_signed, /* complain_on_overflow */
693 bfd_elf_generic_reloc, /* special_function */
694 "GPRELHIGH", /* name */
695 FALSE, /* partial_inplace */
696 0xffff, /* src_mask */
697 0xffff, /* dst_mask */
698 FALSE), /* pcrel_offset */
700 /* The low 16 bits of the displacement from GP to the target. */
701 HOWTO (R_ALPHA_GPRELLOW,
703 1, /* size (0 = byte, 1 = short, 2 = long) */
705 FALSE, /* pc_relative */
707 complain_overflow_dont, /* complain_on_overflow */
708 bfd_elf_generic_reloc, /* special_function */
709 "GPRELLOW", /* name */
710 FALSE, /* partial_inplace */
711 0xffff, /* src_mask */
712 0xffff, /* dst_mask */
713 FALSE), /* pcrel_offset */
715 /* A 16-bit displacement from the GP to the target. */
716 HOWTO (R_ALPHA_GPREL16,
718 1, /* size (0 = byte, 1 = short, 2 = long) */
720 FALSE, /* pc_relative */
722 complain_overflow_signed, /* complain_on_overflow */
723 bfd_elf_generic_reloc, /* special_function */
724 "GPREL16", /* name */
725 FALSE, /* partial_inplace */
726 0xffff, /* src_mask */
727 0xffff, /* dst_mask */
728 FALSE), /* pcrel_offset */
730 /* Skip 20 - 23; deprecated ECOFF relocs. */
736 /* Misc ELF relocations. */
738 /* A dynamic relocation to copy the target into our .dynbss section. */
739 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
740 is present because every other ELF has one, but should not be used
741 because .dynbss is an ugly thing. */
748 complain_overflow_dont,
749 bfd_elf_generic_reloc,
756 /* A dynamic relocation for a .got entry. */
757 HOWTO (R_ALPHA_GLOB_DAT,
763 complain_overflow_dont,
764 bfd_elf_generic_reloc,
771 /* A dynamic relocation for a .plt entry. */
772 HOWTO (R_ALPHA_JMP_SLOT,
778 complain_overflow_dont,
779 bfd_elf_generic_reloc,
786 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
787 HOWTO (R_ALPHA_RELATIVE,
793 complain_overflow_dont,
794 bfd_elf_generic_reloc,
801 /* A 21 bit branch that adjusts for gp loads. */
802 HOWTO (R_ALPHA_BRSGP, /* type */
804 2, /* size (0 = byte, 1 = short, 2 = long) */
806 TRUE, /* pc_relative */
808 complain_overflow_signed, /* complain_on_overflow */
809 bfd_elf_generic_reloc, /* special_function */
811 FALSE, /* partial_inplace */
812 0x1fffff, /* src_mask */
813 0x1fffff, /* dst_mask */
814 TRUE), /* pcrel_offset */
816 /* Creates a tls_index for the symbol in the got. */
817 HOWTO (R_ALPHA_TLSGD, /* type */
819 1, /* size (0 = byte, 1 = short, 2 = long) */
821 FALSE, /* pc_relative */
823 complain_overflow_signed, /* complain_on_overflow */
824 bfd_elf_generic_reloc, /* special_function */
826 FALSE, /* partial_inplace */
827 0xffff, /* src_mask */
828 0xffff, /* dst_mask */
829 FALSE), /* pcrel_offset */
831 /* Creates a tls_index for the (current) module in the got. */
832 HOWTO (R_ALPHA_TLSLDM, /* type */
834 1, /* size (0 = byte, 1 = short, 2 = long) */
836 FALSE, /* pc_relative */
838 complain_overflow_signed, /* complain_on_overflow */
839 bfd_elf_generic_reloc, /* special_function */
841 FALSE, /* partial_inplace */
842 0xffff, /* src_mask */
843 0xffff, /* dst_mask */
844 FALSE), /* pcrel_offset */
846 /* A dynamic relocation for a DTP module entry. */
847 HOWTO (R_ALPHA_DTPMOD64, /* type */
849 4, /* size (0 = byte, 1 = short, 2 = long) */
851 FALSE, /* pc_relative */
853 complain_overflow_bitfield, /* complain_on_overflow */
854 bfd_elf_generic_reloc, /* special_function */
855 "DTPMOD64", /* name */
856 FALSE, /* partial_inplace */
857 MINUS_ONE, /* src_mask */
858 MINUS_ONE, /* dst_mask */
859 FALSE), /* pcrel_offset */
861 /* Creates a 64-bit offset in the got for the displacement
862 from DTP to the target. */
863 HOWTO (R_ALPHA_GOTDTPREL, /* type */
865 1, /* size (0 = byte, 1 = short, 2 = long) */
867 FALSE, /* pc_relative */
869 complain_overflow_signed, /* complain_on_overflow */
870 bfd_elf_generic_reloc, /* special_function */
871 "GOTDTPREL", /* name */
872 FALSE, /* partial_inplace */
873 0xffff, /* src_mask */
874 0xffff, /* dst_mask */
875 FALSE), /* pcrel_offset */
877 /* A dynamic relocation for a displacement from DTP to the target. */
878 HOWTO (R_ALPHA_DTPREL64, /* type */
880 4, /* size (0 = byte, 1 = short, 2 = long) */
882 FALSE, /* pc_relative */
884 complain_overflow_bitfield, /* complain_on_overflow */
885 bfd_elf_generic_reloc, /* special_function */
886 "DTPREL64", /* name */
887 FALSE, /* partial_inplace */
888 MINUS_ONE, /* src_mask */
889 MINUS_ONE, /* dst_mask */
890 FALSE), /* pcrel_offset */
892 /* The high 16 bits of the displacement from DTP to the target. */
893 HOWTO (R_ALPHA_DTPRELHI, /* type */
895 1, /* size (0 = byte, 1 = short, 2 = long) */
897 FALSE, /* pc_relative */
899 complain_overflow_signed, /* complain_on_overflow */
900 bfd_elf_generic_reloc, /* special_function */
901 "DTPRELHI", /* name */
902 FALSE, /* partial_inplace */
903 0xffff, /* src_mask */
904 0xffff, /* dst_mask */
905 FALSE), /* pcrel_offset */
907 /* The low 16 bits of the displacement from DTP to the target. */
908 HOWTO (R_ALPHA_DTPRELLO, /* type */
910 1, /* size (0 = byte, 1 = short, 2 = long) */
912 FALSE, /* pc_relative */
914 complain_overflow_dont, /* complain_on_overflow */
915 bfd_elf_generic_reloc, /* special_function */
916 "DTPRELLO", /* name */
917 FALSE, /* partial_inplace */
918 0xffff, /* src_mask */
919 0xffff, /* dst_mask */
920 FALSE), /* pcrel_offset */
922 /* A 16-bit displacement from DTP to the target. */
923 HOWTO (R_ALPHA_DTPREL16, /* type */
925 1, /* size (0 = byte, 1 = short, 2 = long) */
927 FALSE, /* pc_relative */
929 complain_overflow_signed, /* complain_on_overflow */
930 bfd_elf_generic_reloc, /* special_function */
931 "DTPREL16", /* name */
932 FALSE, /* partial_inplace */
933 0xffff, /* src_mask */
934 0xffff, /* dst_mask */
935 FALSE), /* pcrel_offset */
937 /* Creates a 64-bit offset in the got for the displacement
938 from TP to the target. */
939 HOWTO (R_ALPHA_GOTTPREL, /* type */
941 1, /* size (0 = byte, 1 = short, 2 = long) */
943 FALSE, /* pc_relative */
945 complain_overflow_signed, /* complain_on_overflow */
946 bfd_elf_generic_reloc, /* special_function */
947 "GOTTPREL", /* name */
948 FALSE, /* partial_inplace */
949 0xffff, /* src_mask */
950 0xffff, /* dst_mask */
951 FALSE), /* pcrel_offset */
953 /* A dynamic relocation for a displacement from TP to the target. */
954 HOWTO (R_ALPHA_TPREL64, /* type */
956 4, /* size (0 = byte, 1 = short, 2 = long) */
958 FALSE, /* pc_relative */
960 complain_overflow_bitfield, /* complain_on_overflow */
961 bfd_elf_generic_reloc, /* special_function */
962 "TPREL64", /* name */
963 FALSE, /* partial_inplace */
964 MINUS_ONE, /* src_mask */
965 MINUS_ONE, /* dst_mask */
966 FALSE), /* pcrel_offset */
968 /* The high 16 bits of the displacement from TP to the target. */
969 HOWTO (R_ALPHA_TPRELHI, /* type */
971 1, /* size (0 = byte, 1 = short, 2 = long) */
973 FALSE, /* pc_relative */
975 complain_overflow_signed, /* complain_on_overflow */
976 bfd_elf_generic_reloc, /* special_function */
977 "TPRELHI", /* name */
978 FALSE, /* partial_inplace */
979 0xffff, /* src_mask */
980 0xffff, /* dst_mask */
981 FALSE), /* pcrel_offset */
983 /* The low 16 bits of the displacement from TP to the target. */
984 HOWTO (R_ALPHA_TPRELLO, /* type */
986 1, /* size (0 = byte, 1 = short, 2 = long) */
988 FALSE, /* pc_relative */
990 complain_overflow_dont, /* complain_on_overflow */
991 bfd_elf_generic_reloc, /* special_function */
992 "TPRELLO", /* name */
993 FALSE, /* partial_inplace */
994 0xffff, /* src_mask */
995 0xffff, /* dst_mask */
996 FALSE), /* pcrel_offset */
998 /* A 16-bit displacement from TP to the target. */
999 HOWTO (R_ALPHA_TPREL16, /* type */
1001 1, /* size (0 = byte, 1 = short, 2 = long) */
1003 FALSE, /* pc_relative */
1005 complain_overflow_signed, /* complain_on_overflow */
1006 bfd_elf_generic_reloc, /* special_function */
1007 "TPREL16", /* name */
1008 FALSE, /* partial_inplace */
1009 0xffff, /* src_mask */
1010 0xffff, /* dst_mask */
1011 FALSE), /* pcrel_offset */
1014 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1016 struct elf_reloc_map
1018 bfd_reloc_code_real_type bfd_reloc_val;
1022 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1024 {BFD_RELOC_NONE, R_ALPHA_NONE},
1025 {BFD_RELOC_32, R_ALPHA_REFLONG},
1026 {BFD_RELOC_64, R_ALPHA_REFQUAD},
1027 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
1028 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
1029 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
1030 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
1031 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
1032 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
1033 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
1034 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
1035 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
1036 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
1037 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
1038 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
1039 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
1040 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
1041 {BFD_RELOC_ALPHA_TLSGD, R_ALPHA_TLSGD},
1042 {BFD_RELOC_ALPHA_TLSLDM, R_ALPHA_TLSLDM},
1043 {BFD_RELOC_ALPHA_DTPMOD64, R_ALPHA_DTPMOD64},
1044 {BFD_RELOC_ALPHA_GOTDTPREL16, R_ALPHA_GOTDTPREL},
1045 {BFD_RELOC_ALPHA_DTPREL64, R_ALPHA_DTPREL64},
1046 {BFD_RELOC_ALPHA_DTPREL_HI16, R_ALPHA_DTPRELHI},
1047 {BFD_RELOC_ALPHA_DTPREL_LO16, R_ALPHA_DTPRELLO},
1048 {BFD_RELOC_ALPHA_DTPREL16, R_ALPHA_DTPREL16},
1049 {BFD_RELOC_ALPHA_GOTTPREL16, R_ALPHA_GOTTPREL},
1050 {BFD_RELOC_ALPHA_TPREL64, R_ALPHA_TPREL64},
1051 {BFD_RELOC_ALPHA_TPREL_HI16, R_ALPHA_TPRELHI},
1052 {BFD_RELOC_ALPHA_TPREL_LO16, R_ALPHA_TPRELLO},
1053 {BFD_RELOC_ALPHA_TPREL16, R_ALPHA_TPREL16},
1056 /* Given a BFD reloc type, return a HOWTO structure. */
1058 static reloc_howto_type *
1059 elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1060 bfd_reloc_code_real_type code)
1062 const struct elf_reloc_map *i, *e;
1063 i = e = elf64_alpha_reloc_map;
1064 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1067 if (i->bfd_reloc_val == code)
1068 return &elf64_alpha_howto_table[i->elf_reloc_val];
1073 static reloc_howto_type *
1074 elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1080 i < (sizeof (elf64_alpha_howto_table)
1081 / sizeof (elf64_alpha_howto_table[0]));
1083 if (elf64_alpha_howto_table[i].name != NULL
1084 && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0)
1085 return &elf64_alpha_howto_table[i];
1090 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1093 elf64_alpha_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
1094 Elf_Internal_Rela *dst)
1096 unsigned r_type = ELF64_R_TYPE(dst->r_info);
1097 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
1098 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1101 /* These two relocations create a two-word entry in the got. */
1102 #define alpha_got_entry_size(r_type) \
1103 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1105 /* This is PT_TLS segment p_vaddr. */
1106 #define alpha_get_dtprel_base(info) \
1107 (elf_hash_table (info)->tls_sec->vma)
1109 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1110 is assigned offset round(16, PT_TLS p_align). */
1111 #define alpha_get_tprel_base(info) \
1112 (elf_hash_table (info)->tls_sec->vma \
1113 - align_power ((bfd_vma) 16, \
1114 elf_hash_table (info)->tls_sec->alignment_power))
1116 /* Handle an Alpha specific section when reading an object file. This
1117 is called when bfd_section_from_shdr finds a section with an unknown
1119 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1123 elf64_alpha_section_from_shdr (bfd *abfd,
1124 Elf_Internal_Shdr *hdr,
1130 /* There ought to be a place to keep ELF backend specific flags, but
1131 at the moment there isn't one. We just keep track of the
1132 sections by their name, instead. Fortunately, the ABI gives
1133 suggested names for all the MIPS specific sections, so we will
1134 probably get away with this. */
1135 switch (hdr->sh_type)
1137 case SHT_ALPHA_DEBUG:
1138 if (strcmp (name, ".mdebug") != 0)
1145 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1147 newsect = hdr->bfd_section;
1149 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1151 if (! bfd_set_section_flags (abfd, newsect,
1152 (bfd_get_section_flags (abfd, newsect)
1160 /* Convert Alpha specific section flags to bfd internal section flags. */
1163 elf64_alpha_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
1165 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1166 *flags |= SEC_SMALL_DATA;
1171 /* Set the correct type for an Alpha ELF section. We do this by the
1172 section name, which is a hack, but ought to work. */
1175 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1177 register const char *name;
1179 name = bfd_get_section_name (abfd, sec);
1181 if (strcmp (name, ".mdebug") == 0)
1183 hdr->sh_type = SHT_ALPHA_DEBUG;
1184 /* In a shared object on Irix 5.3, the .mdebug section has an
1185 entsize of 0. FIXME: Does this matter? */
1186 if ((abfd->flags & DYNAMIC) != 0 )
1187 hdr->sh_entsize = 0;
1189 hdr->sh_entsize = 1;
1191 else if ((sec->flags & SEC_SMALL_DATA)
1192 || strcmp (name, ".sdata") == 0
1193 || strcmp (name, ".sbss") == 0
1194 || strcmp (name, ".lit4") == 0
1195 || strcmp (name, ".lit8") == 0)
1196 hdr->sh_flags |= SHF_ALPHA_GPREL;
1201 /* Hook called by the linker routine which adds symbols from an object
1202 file. We use it to put .comm items in .sbss, and not .bss. */
1205 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1206 Elf_Internal_Sym *sym,
1207 const char **namep ATTRIBUTE_UNUSED,
1208 flagword *flagsp ATTRIBUTE_UNUSED,
1209 asection **secp, bfd_vma *valp)
1211 if (sym->st_shndx == SHN_COMMON
1212 && !info->relocatable
1213 && sym->st_size <= elf_gp_size (abfd))
1215 /* Common symbols less than or equal to -G nn bytes are
1216 automatically put into .sbss. */
1218 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1222 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1225 | SEC_LINKER_CREATED));
1231 *valp = sym->st_size;
1237 /* Create the .got section. */
1240 elf64_alpha_create_got_section (bfd *abfd,
1241 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1246 if (! is_alpha_elf (abfd))
1249 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1250 | SEC_LINKER_CREATED);
1251 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1253 || !bfd_set_section_alignment (abfd, s, 3))
1256 alpha_elf_tdata (abfd)->got = s;
1258 /* Make sure the object's gotobj is set to itself so that we default
1259 to every object with its own .got. We'll merge .gots later once
1260 we've collected each object's info. */
1261 alpha_elf_tdata (abfd)->gotobj = abfd;
1266 /* Create all the dynamic sections. */
1269 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1273 struct elf_link_hash_entry *h;
1275 if (! is_alpha_elf (abfd))
1278 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1280 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1281 | SEC_LINKER_CREATED
1282 | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1283 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1284 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4))
1287 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1289 h = _bfd_elf_define_linkage_sym (abfd, info, s,
1290 "_PROCEDURE_LINKAGE_TABLE_");
1291 elf_hash_table (info)->hplt = h;
1295 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1296 | SEC_LINKER_CREATED | SEC_READONLY);
1297 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1298 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1301 if (elf64_alpha_use_secureplt)
1303 flags = SEC_ALLOC | SEC_LINKER_CREATED;
1304 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1305 if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1309 /* We may or may not have created a .got section for this object, but
1310 we definitely havn't done the rest of the work. */
1312 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1314 if (!elf64_alpha_create_got_section (abfd, info))
1318 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1319 | SEC_LINKER_CREATED | SEC_READONLY);
1320 s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1322 || !bfd_set_section_alignment (abfd, s, 3))
1325 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1326 dynobj's .got section. We don't do this in the linker script
1327 because we don't want to define the symbol if we are not creating
1328 a global offset table. */
1329 h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1330 "_GLOBAL_OFFSET_TABLE_");
1331 elf_hash_table (info)->hgot = h;
1338 /* Read ECOFF debugging information from a .mdebug section into a
1339 ecoff_debug_info structure. */
1342 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1343 struct ecoff_debug_info *debug)
1346 const struct ecoff_debug_swap *swap;
1347 char *ext_hdr = NULL;
1349 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1350 memset (debug, 0, sizeof (*debug));
1352 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1353 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1356 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1357 swap->external_hdr_size))
1360 symhdr = &debug->symbolic_header;
1361 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1363 /* The symbolic header contains absolute file offsets and sizes to
1365 #define READ(ptr, offset, count, size, type) \
1366 if (symhdr->count == 0) \
1367 debug->ptr = NULL; \
1370 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1371 debug->ptr = (type) bfd_malloc (amt); \
1372 if (debug->ptr == NULL) \
1373 goto error_return; \
1374 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1375 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1376 goto error_return; \
1379 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1380 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1381 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1382 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1383 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1384 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1386 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1387 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1388 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1389 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1390 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1398 if (ext_hdr != NULL)
1400 if (debug->line != NULL)
1402 if (debug->external_dnr != NULL)
1403 free (debug->external_dnr);
1404 if (debug->external_pdr != NULL)
1405 free (debug->external_pdr);
1406 if (debug->external_sym != NULL)
1407 free (debug->external_sym);
1408 if (debug->external_opt != NULL)
1409 free (debug->external_opt);
1410 if (debug->external_aux != NULL)
1411 free (debug->external_aux);
1412 if (debug->ss != NULL)
1414 if (debug->ssext != NULL)
1415 free (debug->ssext);
1416 if (debug->external_fdr != NULL)
1417 free (debug->external_fdr);
1418 if (debug->external_rfd != NULL)
1419 free (debug->external_rfd);
1420 if (debug->external_ext != NULL)
1421 free (debug->external_ext);
1425 /* Alpha ELF local labels start with '$'. */
1428 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1430 return name[0] == '$';
1433 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1434 routine in order to handle the ECOFF debugging information. We
1435 still call this mips_elf_find_line because of the slot
1436 find_line_info in elf_obj_tdata is declared that way. */
1438 struct mips_elf_find_line
1440 struct ecoff_debug_info d;
1441 struct ecoff_find_line i;
1445 elf64_alpha_find_nearest_line (bfd *abfd, asection *section, asymbol **symbols,
1446 bfd_vma offset, const char **filename_ptr,
1447 const char **functionname_ptr,
1448 unsigned int *line_ptr)
1452 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
1453 section, symbols, offset,
1454 filename_ptr, functionname_ptr,
1456 &elf_tdata (abfd)->dwarf2_find_line_info))
1459 msec = bfd_get_section_by_name (abfd, ".mdebug");
1463 struct mips_elf_find_line *fi;
1464 const struct ecoff_debug_swap * const swap =
1465 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1467 /* If we are called during a link, alpha_elf_final_link may have
1468 cleared the SEC_HAS_CONTENTS field. We force it back on here
1469 if appropriate (which it normally will be). */
1470 origflags = msec->flags;
1471 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1472 msec->flags |= SEC_HAS_CONTENTS;
1474 fi = elf_tdata (abfd)->find_line_info;
1477 bfd_size_type external_fdr_size;
1480 struct fdr *fdr_ptr;
1481 bfd_size_type amt = sizeof (struct mips_elf_find_line);
1483 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
1486 msec->flags = origflags;
1490 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1492 msec->flags = origflags;
1496 /* Swap in the FDR information. */
1497 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1498 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1499 if (fi->d.fdr == NULL)
1501 msec->flags = origflags;
1504 external_fdr_size = swap->external_fdr_size;
1505 fdr_ptr = fi->d.fdr;
1506 fraw_src = (char *) fi->d.external_fdr;
1507 fraw_end = (fraw_src
1508 + fi->d.symbolic_header.ifdMax * external_fdr_size);
1509 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1510 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
1512 elf_tdata (abfd)->find_line_info = fi;
1514 /* Note that we don't bother to ever free this information.
1515 find_nearest_line is either called all the time, as in
1516 objdump -l, so the information should be saved, or it is
1517 rarely called, as in ld error messages, so the memory
1518 wasted is unimportant. Still, it would probably be a
1519 good idea for free_cached_info to throw it away. */
1522 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1523 &fi->i, filename_ptr, functionname_ptr,
1526 msec->flags = origflags;
1530 msec->flags = origflags;
1533 /* Fall back on the generic ELF find_nearest_line routine. */
1535 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
1536 filename_ptr, functionname_ptr,
1540 /* Structure used to pass information to alpha_elf_output_extsym. */
1545 struct bfd_link_info *info;
1546 struct ecoff_debug_info *debug;
1547 const struct ecoff_debug_swap *swap;
1552 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, PTR data)
1554 struct extsym_info *einfo = (struct extsym_info *) data;
1556 asection *sec, *output_section;
1558 if (h->root.indx == -2)
1560 else if ((h->root.def_dynamic
1561 || h->root.ref_dynamic
1562 || h->root.root.type == bfd_link_hash_new)
1563 && !h->root.def_regular
1564 && !h->root.ref_regular)
1566 else if (einfo->info->strip == strip_all
1567 || (einfo->info->strip == strip_some
1568 && bfd_hash_lookup (einfo->info->keep_hash,
1569 h->root.root.root.string,
1570 FALSE, FALSE) == NULL))
1578 if (h->esym.ifd == -2)
1581 h->esym.cobol_main = 0;
1582 h->esym.weakext = 0;
1583 h->esym.reserved = 0;
1584 h->esym.ifd = ifdNil;
1585 h->esym.asym.value = 0;
1586 h->esym.asym.st = stGlobal;
1588 if (h->root.root.type != bfd_link_hash_defined
1589 && h->root.root.type != bfd_link_hash_defweak)
1590 h->esym.asym.sc = scAbs;
1595 sec = h->root.root.u.def.section;
1596 output_section = sec->output_section;
1598 /* When making a shared library and symbol h is the one from
1599 the another shared library, OUTPUT_SECTION may be null. */
1600 if (output_section == NULL)
1601 h->esym.asym.sc = scUndefined;
1604 name = bfd_section_name (output_section->owner, output_section);
1606 if (strcmp (name, ".text") == 0)
1607 h->esym.asym.sc = scText;
1608 else if (strcmp (name, ".data") == 0)
1609 h->esym.asym.sc = scData;
1610 else if (strcmp (name, ".sdata") == 0)
1611 h->esym.asym.sc = scSData;
1612 else if (strcmp (name, ".rodata") == 0
1613 || strcmp (name, ".rdata") == 0)
1614 h->esym.asym.sc = scRData;
1615 else if (strcmp (name, ".bss") == 0)
1616 h->esym.asym.sc = scBss;
1617 else if (strcmp (name, ".sbss") == 0)
1618 h->esym.asym.sc = scSBss;
1619 else if (strcmp (name, ".init") == 0)
1620 h->esym.asym.sc = scInit;
1621 else if (strcmp (name, ".fini") == 0)
1622 h->esym.asym.sc = scFini;
1624 h->esym.asym.sc = scAbs;
1628 h->esym.asym.reserved = 0;
1629 h->esym.asym.index = indexNil;
1632 if (h->root.root.type == bfd_link_hash_common)
1633 h->esym.asym.value = h->root.root.u.c.size;
1634 else if (h->root.root.type == bfd_link_hash_defined
1635 || h->root.root.type == bfd_link_hash_defweak)
1637 if (h->esym.asym.sc == scCommon)
1638 h->esym.asym.sc = scBss;
1639 else if (h->esym.asym.sc == scSCommon)
1640 h->esym.asym.sc = scSBss;
1642 sec = h->root.root.u.def.section;
1643 output_section = sec->output_section;
1644 if (output_section != NULL)
1645 h->esym.asym.value = (h->root.root.u.def.value
1646 + sec->output_offset
1647 + output_section->vma);
1649 h->esym.asym.value = 0;
1652 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1653 h->root.root.root.string,
1656 einfo->failed = TRUE;
1663 /* Search for and possibly create a got entry. */
1665 static struct alpha_elf_got_entry *
1666 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1667 unsigned long r_type, unsigned long r_symndx,
1670 struct alpha_elf_got_entry *gotent;
1671 struct alpha_elf_got_entry **slot;
1674 slot = &h->got_entries;
1677 /* This is a local .got entry -- record for merge. */
1679 struct alpha_elf_got_entry **local_got_entries;
1681 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1682 if (!local_got_entries)
1685 Elf_Internal_Shdr *symtab_hdr;
1687 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1688 size = symtab_hdr->sh_info;
1689 size *= sizeof (struct alpha_elf_got_entry *);
1692 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1693 if (!local_got_entries)
1696 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1699 slot = &local_got_entries[r_symndx];
1702 for (gotent = *slot; gotent ; gotent = gotent->next)
1703 if (gotent->gotobj == abfd
1704 && gotent->reloc_type == r_type
1705 && gotent->addend == r_addend)
1713 amt = sizeof (struct alpha_elf_got_entry);
1714 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1718 gotent->gotobj = abfd;
1719 gotent->addend = r_addend;
1720 gotent->got_offset = -1;
1721 gotent->plt_offset = -1;
1722 gotent->use_count = 1;
1723 gotent->reloc_type = r_type;
1724 gotent->reloc_done = 0;
1725 gotent->reloc_xlated = 0;
1727 gotent->next = *slot;
1730 entry_size = alpha_got_entry_size (r_type);
1731 alpha_elf_tdata (abfd)->total_got_size += entry_size;
1733 alpha_elf_tdata(abfd)->local_got_size += entry_size;
1736 gotent->use_count += 1;
1742 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1744 return ((ah->root.type == STT_FUNC
1745 || ah->root.root.type == bfd_link_hash_undefweak
1746 || ah->root.root.type == bfd_link_hash_undefined)
1747 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1748 && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1751 /* Handle dynamic relocations when doing an Alpha ELF link. */
1754 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1755 asection *sec, const Elf_Internal_Rela *relocs)
1759 Elf_Internal_Shdr *symtab_hdr;
1760 struct alpha_elf_link_hash_entry **sym_hashes;
1761 const Elf_Internal_Rela *rel, *relend;
1764 if (info->relocatable)
1767 /* Don't do anything special with non-loaded, non-alloced sections.
1768 In particular, any relocs in such sections should not affect GOT
1769 and PLT reference counting (ie. we don't allow them to create GOT
1770 or PLT entries), there's no possibility or desire to optimize TLS
1771 relocs, and there's not much point in propagating relocs to shared
1772 libs that the dynamic linker won't relocate. */
1773 if ((sec->flags & SEC_ALLOC) == 0)
1776 BFD_ASSERT (is_alpha_elf (abfd));
1778 dynobj = elf_hash_table (info)->dynobj;
1780 elf_hash_table (info)->dynobj = dynobj = abfd;
1783 symtab_hdr = &elf_symtab_hdr (abfd);
1784 sym_hashes = alpha_elf_sym_hashes (abfd);
1786 relend = relocs + sec->reloc_count;
1787 for (rel = relocs; rel < relend; ++rel)
1795 unsigned long r_symndx, r_type;
1796 struct alpha_elf_link_hash_entry *h;
1797 unsigned int gotent_flags;
1798 bfd_boolean maybe_dynamic;
1802 r_symndx = ELF64_R_SYM (rel->r_info);
1803 if (r_symndx < symtab_hdr->sh_info)
1807 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1809 while (h->root.root.type == bfd_link_hash_indirect
1810 || h->root.root.type == bfd_link_hash_warning)
1811 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1813 h->root.ref_regular = 1;
1816 /* We can only get preliminary data on whether a symbol is
1817 locally or externally defined, as not all of the input files
1818 have yet been processed. Do something with what we know, as
1819 this may help reduce memory usage and processing time later. */
1820 maybe_dynamic = FALSE;
1821 if (h && ((info->shared
1823 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1824 || !h->root.def_regular
1825 || h->root.root.type == bfd_link_hash_defweak))
1826 maybe_dynamic = TRUE;
1830 r_type = ELF64_R_TYPE (rel->r_info);
1831 addend = rel->r_addend;
1835 case R_ALPHA_LITERAL:
1836 need = NEED_GOT | NEED_GOT_ENTRY;
1838 /* Remember how this literal is used from its LITUSEs.
1839 This will be important when it comes to decide if we can
1840 create a .plt entry for a function symbol. */
1841 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
1842 if (rel->r_addend >= 1 && rel->r_addend <= 6)
1843 gotent_flags |= 1 << rel->r_addend;
1846 /* No LITUSEs -- presumably the address is used somehow. */
1847 if (gotent_flags == 0)
1848 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
1851 case R_ALPHA_GPDISP:
1852 case R_ALPHA_GPREL16:
1853 case R_ALPHA_GPREL32:
1854 case R_ALPHA_GPRELHIGH:
1855 case R_ALPHA_GPRELLOW:
1860 case R_ALPHA_REFLONG:
1861 case R_ALPHA_REFQUAD:
1862 if (info->shared || maybe_dynamic)
1866 case R_ALPHA_TLSLDM:
1867 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1868 reloc to the STN_UNDEF (0) symbol so that they all match. */
1869 r_symndx = STN_UNDEF;
1871 maybe_dynamic = FALSE;
1875 case R_ALPHA_GOTDTPREL:
1876 need = NEED_GOT | NEED_GOT_ENTRY;
1879 case R_ALPHA_GOTTPREL:
1880 need = NEED_GOT | NEED_GOT_ENTRY;
1881 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
1883 info->flags |= DF_STATIC_TLS;
1886 case R_ALPHA_TPREL64:
1887 if (info->shared && !info->pie)
1889 info->flags |= DF_STATIC_TLS;
1892 else if (maybe_dynamic)
1897 if (need & NEED_GOT)
1899 if (alpha_elf_tdata(abfd)->gotobj == NULL)
1901 if (!elf64_alpha_create_got_section (abfd, info))
1906 if (need & NEED_GOT_ENTRY)
1908 struct alpha_elf_got_entry *gotent;
1910 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
1916 gotent->flags |= gotent_flags;
1919 gotent_flags |= h->flags;
1920 h->flags = gotent_flags;
1922 /* Make a guess as to whether a .plt entry is needed. */
1923 /* ??? It appears that we won't make it into
1924 adjust_dynamic_symbol for symbols that remain
1925 totally undefined. Copying this check here means
1926 we can create a plt entry for them too. */
1928 = (maybe_dynamic && elf64_alpha_want_plt (h));
1933 if (need & NEED_DYNREL)
1935 /* We need to create the section here now whether we eventually
1936 use it or not so that it gets mapped to an output section by
1937 the linker. If not used, we'll kill it in size_dynamic_sections. */
1940 sreloc = _bfd_elf_make_dynamic_reloc_section
1941 (sec, dynobj, 3, abfd, /*rela?*/ TRUE);
1949 /* Since we havn't seen all of the input symbols yet, we
1950 don't know whether we'll actually need a dynamic relocation
1951 entry for this reloc. So make a record of it. Once we
1952 find out if this thing needs dynamic relocation we'll
1953 expand the relocation sections by the appropriate amount. */
1955 struct alpha_elf_reloc_entry *rent;
1957 for (rent = h->reloc_entries; rent; rent = rent->next)
1958 if (rent->rtype == r_type && rent->srel == sreloc)
1963 amt = sizeof (struct alpha_elf_reloc_entry);
1964 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
1968 rent->srel = sreloc;
1969 rent->rtype = r_type;
1971 rent->reltext = (sec->flags & SEC_READONLY) != 0;
1973 rent->next = h->reloc_entries;
1974 h->reloc_entries = rent;
1979 else if (info->shared)
1981 /* If this is a shared library, and the section is to be
1982 loaded into memory, we need a RELATIVE reloc. */
1983 sreloc->size += sizeof (Elf64_External_Rela);
1984 if (sec->flags & SEC_READONLY)
1985 info->flags |= DF_TEXTREL;
1993 /* Return the section that should be marked against GC for a given
1997 elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info,
1998 Elf_Internal_Rela *rel,
1999 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
2001 /* These relocations don't really reference a symbol. Instead we store
2002 extra data in their addend slot. Ignore the symbol. */
2003 switch (ELF64_R_TYPE (rel->r_info))
2005 case R_ALPHA_LITUSE:
2006 case R_ALPHA_GPDISP:
2011 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2014 /* Update the got entry reference counts for the section being removed. */
2017 elf64_alpha_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
2018 asection *sec, const Elf_Internal_Rela *relocs)
2020 Elf_Internal_Shdr *symtab_hdr;
2021 struct alpha_elf_link_hash_entry **sym_hashes;
2022 const Elf_Internal_Rela *rel, *relend;
2024 if (info->relocatable)
2027 symtab_hdr = &elf_symtab_hdr (abfd);
2028 sym_hashes = alpha_elf_sym_hashes (abfd);
2030 relend = relocs + sec->reloc_count;
2031 for (rel = relocs; rel < relend; rel++)
2033 unsigned long r_symndx, r_type;
2034 struct alpha_elf_link_hash_entry *h = NULL;
2035 struct alpha_elf_got_entry *gotent;
2037 r_symndx = ELF64_R_SYM (rel->r_info);
2038 if (r_symndx >= symtab_hdr->sh_info)
2040 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2041 while (h->root.root.type == bfd_link_hash_indirect
2042 || h->root.root.type == bfd_link_hash_warning)
2043 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2046 r_type = ELF64_R_TYPE (rel->r_info);
2049 case R_ALPHA_LITERAL:
2050 /* ??? Ignore re-computation of gotent_flags. We're not
2051 carrying a use-count for each bit in that mask. */
2054 case R_ALPHA_GOTDTPREL:
2055 case R_ALPHA_GOTTPREL:
2056 /* Fetch the got entry from the tables. */
2057 gotent = get_got_entry (abfd, h, r_type, r_symndx, rel->r_addend);
2059 /* The got entry *must* exist, since we should have created it
2060 before during check_relocs. Also note that get_got_entry
2061 assumed this was going to be another use, and so incremented
2062 the use count again. Thus the use count must be at least the
2063 one real use and the "use" we just added. */
2064 if (gotent == NULL || gotent->use_count < 2)
2069 gotent->use_count -= 2;
2080 /* Adjust a symbol defined by a dynamic object and referenced by a
2081 regular object. The current definition is in some section of the
2082 dynamic object, but we're not including those sections. We have to
2083 change the definition to something the rest of the link can
2087 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2088 struct elf_link_hash_entry *h)
2092 struct alpha_elf_link_hash_entry *ah;
2094 dynobj = elf_hash_table(info)->dynobj;
2095 ah = (struct alpha_elf_link_hash_entry *)h;
2097 /* Now that we've seen all of the input symbols, finalize our decision
2098 about whether this symbol should get a .plt entry. Irritatingly, it
2099 is common for folk to leave undefined symbols in shared libraries,
2100 and they still expect lazy binding; accept undefined symbols in lieu
2102 if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2104 h->needs_plt = TRUE;
2106 s = bfd_get_section_by_name(dynobj, ".plt");
2107 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2110 /* We need one plt entry per got subsection. Delay allocation of
2111 the actual plt entries until size_plt_section, called from
2112 size_dynamic_sections or during relaxation. */
2117 h->needs_plt = FALSE;
2119 /* If this is a weak symbol, and there is a real definition, the
2120 processor independent code will have arranged for us to see the
2121 real definition first, and we can just use the same value. */
2122 if (h->u.weakdef != NULL)
2124 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2125 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2126 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2127 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2131 /* This is a reference to a symbol defined by a dynamic object which
2132 is not a function. The Alpha, since it uses .got entries for all
2133 symbols even in regular objects, does not need the hackery of a
2134 .dynbss section and COPY dynamic relocations. */
2139 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2142 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2143 const Elf_Internal_Sym *isym,
2144 bfd_boolean definition,
2145 bfd_boolean dynamic)
2147 if (!dynamic && definition)
2148 h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2149 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
2152 /* Symbol versioning can create new symbols, and make our old symbols
2153 indirect to the new ones. Consolidate the got and reloc information
2154 in these situations. */
2157 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2158 struct elf_link_hash_entry *dir,
2159 struct elf_link_hash_entry *ind)
2161 struct alpha_elf_link_hash_entry *hi
2162 = (struct alpha_elf_link_hash_entry *) ind;
2163 struct alpha_elf_link_hash_entry *hs
2164 = (struct alpha_elf_link_hash_entry *) dir;
2166 /* Do the merging in the superclass. */
2167 _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2169 /* Merge the flags. Whee. */
2170 hs->flags |= hi->flags;
2172 /* ??? It's unclear to me what's really supposed to happen when
2173 "merging" defweak and defined symbols, given that we don't
2174 actually throw away the defweak. This more-or-less copies
2175 the logic related to got and plt entries in the superclass. */
2176 if (ind->root.type != bfd_link_hash_indirect)
2179 /* Merge the .got entries. Cannibalize the old symbol's list in
2180 doing so, since we don't need it anymore. */
2182 if (hs->got_entries == NULL)
2183 hs->got_entries = hi->got_entries;
2186 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2188 gsh = hs->got_entries;
2189 for (gi = hi->got_entries; gi ; gi = gin)
2192 for (gs = gsh; gs ; gs = gs->next)
2193 if (gi->gotobj == gs->gotobj
2194 && gi->reloc_type == gs->reloc_type
2195 && gi->addend == gs->addend)
2197 gi->use_count += gs->use_count;
2200 gi->next = hs->got_entries;
2201 hs->got_entries = gi;
2205 hi->got_entries = NULL;
2207 /* And similar for the reloc entries. */
2209 if (hs->reloc_entries == NULL)
2210 hs->reloc_entries = hi->reloc_entries;
2213 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2215 rsh = hs->reloc_entries;
2216 for (ri = hi->reloc_entries; ri ; ri = rin)
2219 for (rs = rsh; rs ; rs = rs->next)
2220 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2222 rs->count += ri->count;
2225 ri->next = hs->reloc_entries;
2226 hs->reloc_entries = ri;
2230 hi->reloc_entries = NULL;
2233 /* Is it possible to merge two object file's .got tables? */
2236 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2238 int total = alpha_elf_tdata (a)->total_got_size;
2241 /* Trivial quick fallout test. */
2242 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2245 /* By their nature, local .got entries cannot be merged. */
2246 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2249 /* Failing the common trivial comparison, we must effectively
2250 perform the merge. Not actually performing the merge means that
2251 we don't have to store undo information in case we fail. */
2252 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2254 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2255 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2258 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2259 for (i = 0; i < n; ++i)
2261 struct alpha_elf_got_entry *ae, *be;
2262 struct alpha_elf_link_hash_entry *h;
2265 while (h->root.root.type == bfd_link_hash_indirect
2266 || h->root.root.type == bfd_link_hash_warning)
2267 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2269 for (be = h->got_entries; be ; be = be->next)
2271 if (be->use_count == 0)
2273 if (be->gotobj != b)
2276 for (ae = h->got_entries; ae ; ae = ae->next)
2278 && ae->reloc_type == be->reloc_type
2279 && ae->addend == be->addend)
2282 total += alpha_got_entry_size (be->reloc_type);
2283 if (total > MAX_GOT_SIZE)
2293 /* Actually merge two .got tables. */
2296 elf64_alpha_merge_gots (bfd *a, bfd *b)
2298 int total = alpha_elf_tdata (a)->total_got_size;
2301 /* Remember local expansion. */
2303 int e = alpha_elf_tdata (b)->local_got_size;
2305 alpha_elf_tdata (a)->local_got_size += e;
2308 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2310 struct alpha_elf_got_entry **local_got_entries;
2311 struct alpha_elf_link_hash_entry **hashes;
2312 Elf_Internal_Shdr *symtab_hdr;
2315 /* Let the local .got entries know they are part of a new subsegment. */
2316 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2317 if (local_got_entries)
2319 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2320 for (i = 0; i < n; ++i)
2322 struct alpha_elf_got_entry *ent;
2323 for (ent = local_got_entries[i]; ent; ent = ent->next)
2328 /* Merge the global .got entries. */
2329 hashes = alpha_elf_sym_hashes (bsub);
2330 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2332 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2333 for (i = 0; i < n; ++i)
2335 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2336 struct alpha_elf_link_hash_entry *h;
2339 while (h->root.root.type == bfd_link_hash_indirect
2340 || h->root.root.type == bfd_link_hash_warning)
2341 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2343 pbe = start = &h->got_entries;
2344 while ((be = *pbe) != NULL)
2346 if (be->use_count == 0)
2349 memset (be, 0xa5, sizeof (*be));
2352 if (be->gotobj != b)
2355 for (ae = *start; ae ; ae = ae->next)
2357 && ae->reloc_type == be->reloc_type
2358 && ae->addend == be->addend)
2360 ae->flags |= be->flags;
2361 ae->use_count += be->use_count;
2363 memset (be, 0xa5, sizeof (*be));
2367 total += alpha_got_entry_size (be->reloc_type);
2375 alpha_elf_tdata (bsub)->gotobj = a;
2377 alpha_elf_tdata (a)->total_got_size = total;
2379 /* Merge the two in_got chains. */
2384 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2387 alpha_elf_tdata (bsub)->in_got_link_next = b;
2391 /* Calculate the offsets for the got entries. */
2394 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2395 PTR arg ATTRIBUTE_UNUSED)
2397 struct alpha_elf_got_entry *gotent;
2399 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2400 if (gotent->use_count > 0)
2402 struct alpha_elf_obj_tdata *td;
2403 bfd_size_type *plge;
2405 td = alpha_elf_tdata (gotent->gotobj);
2406 plge = &td->got->size;
2407 gotent->got_offset = *plge;
2408 *plge += alpha_got_entry_size (gotent->reloc_type);
2415 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2418 struct alpha_elf_link_hash_table * htab;
2420 htab = alpha_elf_hash_table (info);
2423 got_list = htab->got_list;
2425 /* First, zero out the .got sizes, as we may be recalculating the
2426 .got after optimizing it. */
2427 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2428 alpha_elf_tdata(i)->got->size = 0;
2430 /* Next, fill in the offsets for all the global entries. */
2431 alpha_elf_link_hash_traverse (htab,
2432 elf64_alpha_calc_got_offsets_for_symbol,
2435 /* Finally, fill in the offsets for the local entries. */
2436 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2438 bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2441 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2443 struct alpha_elf_got_entry **local_got_entries, *gotent;
2446 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2447 if (!local_got_entries)
2450 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2451 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2452 if (gotent->use_count > 0)
2454 gotent->got_offset = got_offset;
2455 got_offset += alpha_got_entry_size (gotent->reloc_type);
2459 alpha_elf_tdata(i)->got->size = got_offset;
2463 /* Constructs the gots. */
2466 elf64_alpha_size_got_sections (struct bfd_link_info *info)
2468 bfd *i, *got_list, *cur_got_obj = NULL;
2469 struct alpha_elf_link_hash_table * htab;
2471 htab = alpha_elf_hash_table (info);
2474 got_list = htab->got_list;
2476 /* On the first time through, pretend we have an existing got list
2477 consisting of all of the input files. */
2478 if (got_list == NULL)
2480 for (i = info->input_bfds; i ; i = i->link_next)
2484 if (! is_alpha_elf (i))
2487 this_got = alpha_elf_tdata (i)->gotobj;
2488 if (this_got == NULL)
2491 /* We are assuming no merging has yet occurred. */
2492 BFD_ASSERT (this_got == i);
2494 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2496 /* Yikes! A single object file has too many entries. */
2497 (*_bfd_error_handler)
2498 (_("%B: .got subsegment exceeds 64K (size %d)"),
2499 i, alpha_elf_tdata (this_got)->total_got_size);
2503 if (got_list == NULL)
2504 got_list = this_got;
2506 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2507 cur_got_obj = this_got;
2510 /* Strange degenerate case of no got references. */
2511 if (got_list == NULL)
2514 htab->got_list = got_list;
2517 cur_got_obj = got_list;
2518 if (cur_got_obj == NULL)
2521 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2524 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2526 elf64_alpha_merge_gots (cur_got_obj, i);
2528 alpha_elf_tdata(i)->got->size = 0;
2529 i = alpha_elf_tdata(i)->got_link_next;
2530 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2535 i = alpha_elf_tdata(i)->got_link_next;
2539 /* Once the gots have been merged, fill in the got offsets for
2540 everything therein. */
2541 elf64_alpha_calc_got_offsets (info);
2547 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h, PTR data)
2549 asection *splt = (asection *) data;
2550 struct alpha_elf_got_entry *gotent;
2551 bfd_boolean saw_one = FALSE;
2553 /* If we didn't need an entry before, we still don't. */
2554 if (!h->root.needs_plt)
2557 /* For each LITERAL got entry still in use, allocate a plt entry. */
2558 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2559 if (gotent->reloc_type == R_ALPHA_LITERAL
2560 && gotent->use_count > 0)
2562 if (splt->size == 0)
2563 splt->size = PLT_HEADER_SIZE;
2564 gotent->plt_offset = splt->size;
2565 splt->size += PLT_ENTRY_SIZE;
2569 /* If there weren't any, there's no longer a need for the PLT entry. */
2571 h->root.needs_plt = FALSE;
2576 /* Called from relax_section to rebuild the PLT in light of potential changes
2577 in the function's status. */
2580 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2582 asection *splt, *spltrel, *sgotplt;
2583 unsigned long entries;
2585 struct alpha_elf_link_hash_table * htab;
2587 htab = alpha_elf_hash_table (info);
2591 dynobj = elf_hash_table(info)->dynobj;
2592 splt = bfd_get_section_by_name (dynobj, ".plt");
2598 alpha_elf_link_hash_traverse (htab,
2599 elf64_alpha_size_plt_section_1, splt);
2601 /* Every plt entry requires a JMP_SLOT relocation. */
2602 spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
2606 if (elf64_alpha_use_secureplt)
2607 entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2609 entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2611 spltrel->size = entries * sizeof (Elf64_External_Rela);
2613 /* When using the secureplt, we need two words somewhere in the data
2614 segment for the dynamic linker to tell us where to go. This is the
2615 entire contents of the .got.plt section. */
2616 if (elf64_alpha_use_secureplt)
2618 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2619 sgotplt->size = entries ? 16 : 0;
2624 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2625 struct bfd_link_info *info)
2628 struct alpha_elf_link_hash_table * htab;
2630 if (info->relocatable)
2633 htab = alpha_elf_hash_table (info);
2637 if (!elf64_alpha_size_got_sections (info))
2640 /* Allocate space for all of the .got subsections. */
2642 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2644 asection *s = alpha_elf_tdata(i)->got;
2647 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2648 if (s->contents == NULL)
2656 /* The number of dynamic relocations required by a static relocation. */
2659 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2663 /* May appear in GOT entries. */
2665 return (dynamic ? 2 : shared ? 1 : 0);
2666 case R_ALPHA_TLSLDM:
2668 case R_ALPHA_LITERAL:
2669 return dynamic || shared;
2670 case R_ALPHA_GOTTPREL:
2671 return dynamic || (shared && !pie);
2672 case R_ALPHA_GOTDTPREL:
2675 /* May appear in data sections. */
2676 case R_ALPHA_REFLONG:
2677 case R_ALPHA_REFQUAD:
2678 return dynamic || shared;
2679 case R_ALPHA_TPREL64:
2680 return dynamic || (shared && !pie);
2682 /* Everything else is illegal. We'll issue an error during
2683 relocate_section. */
2689 /* Work out the sizes of the dynamic relocation entries. */
2692 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2693 struct bfd_link_info *info)
2695 bfd_boolean dynamic;
2696 struct alpha_elf_reloc_entry *relent;
2697 unsigned long entries;
2699 /* If the symbol was defined as a common symbol in a regular object
2700 file, and there was no definition in any dynamic object, then the
2701 linker will have allocated space for the symbol in a common
2702 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2703 set. This is done for dynamic symbols in
2704 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2705 symbols, somehow. */
2706 if (!h->root.def_regular
2707 && h->root.ref_regular
2708 && !h->root.def_dynamic
2709 && (h->root.root.type == bfd_link_hash_defined
2710 || h->root.root.type == bfd_link_hash_defweak)
2711 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2712 h->root.def_regular = 1;
2714 /* If the symbol is dynamic, we'll need all the relocations in their
2715 natural form. If this is a shared object, and it has been forced
2716 local, we'll need the same number of RELATIVE relocations. */
2717 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2719 /* If the symbol is a hidden undefined weak, then we never have any
2720 relocations. Avoid the loop which may want to add RELATIVE relocs
2721 based on info->shared. */
2722 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2725 for (relent = h->reloc_entries; relent; relent = relent->next)
2727 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2728 info->shared, info->pie);
2731 relent->srel->size +=
2732 entries * sizeof (Elf64_External_Rela) * relent->count;
2733 if (relent->reltext)
2734 info->flags |= DT_TEXTREL;
2741 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2745 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2746 struct bfd_link_info *info)
2748 bfd_boolean dynamic;
2749 struct alpha_elf_got_entry *gotent;
2750 unsigned long entries;
2752 /* If we're using a plt for this symbol, then all of its relocations
2753 for its got entries go into .rela.plt. */
2754 if (h->root.needs_plt)
2757 /* If the symbol is dynamic, we'll need all the relocations in their
2758 natural form. If this is a shared object, and it has been forced
2759 local, we'll need the same number of RELATIVE relocations. */
2760 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2762 /* If the symbol is a hidden undefined weak, then we never have any
2763 relocations. Avoid the loop which may want to add RELATIVE relocs
2764 based on info->shared. */
2765 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2769 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2770 if (gotent->use_count > 0)
2771 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2772 info->shared, info->pie);
2776 bfd *dynobj = elf_hash_table(info)->dynobj;
2777 asection *srel = bfd_get_section_by_name (dynobj, ".rela.got");
2778 BFD_ASSERT (srel != NULL);
2779 srel->size += sizeof (Elf64_External_Rela) * entries;
2785 /* Set the sizes of the dynamic relocation sections. */
2788 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2790 unsigned long entries;
2793 struct alpha_elf_link_hash_table * htab;
2795 htab = alpha_elf_hash_table (info);
2799 /* Shared libraries often require RELATIVE relocs, and some relocs
2800 require attention for the main application as well. */
2803 for (i = htab->got_list;
2804 i ; i = alpha_elf_tdata(i)->got_link_next)
2808 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2810 struct alpha_elf_got_entry **local_got_entries, *gotent;
2813 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2814 if (!local_got_entries)
2817 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2818 for (gotent = local_got_entries[k];
2819 gotent ; gotent = gotent->next)
2820 if (gotent->use_count > 0)
2821 entries += (alpha_dynamic_entries_for_reloc
2822 (gotent->reloc_type, 0, info->shared, info->pie));
2826 dynobj = elf_hash_table(info)->dynobj;
2827 srel = bfd_get_section_by_name (dynobj, ".rela.got");
2830 BFD_ASSERT (entries == 0);
2833 srel->size = sizeof (Elf64_External_Rela) * entries;
2835 /* Now do the non-local symbols. */
2836 alpha_elf_link_hash_traverse (htab,
2837 elf64_alpha_size_rela_got_1, info);
2840 /* Set the sizes of the dynamic sections. */
2843 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2844 struct bfd_link_info *info)
2849 struct alpha_elf_link_hash_table * htab;
2851 htab = alpha_elf_hash_table (info);
2855 dynobj = elf_hash_table(info)->dynobj;
2856 BFD_ASSERT(dynobj != NULL);
2858 if (elf_hash_table (info)->dynamic_sections_created)
2860 /* Set the contents of the .interp section to the interpreter. */
2861 if (info->executable)
2863 s = bfd_get_section_by_name (dynobj, ".interp");
2864 BFD_ASSERT (s != NULL);
2865 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2866 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2869 /* Now that we've seen all of the input files, we can decide which
2870 symbols need dynamic relocation entries and which don't. We've
2871 collected information in check_relocs that we can now apply to
2872 size the dynamic relocation sections. */
2873 alpha_elf_link_hash_traverse (htab,
2874 elf64_alpha_calc_dynrel_sizes, info);
2876 elf64_alpha_size_rela_got_section (info);
2877 elf64_alpha_size_plt_section (info);
2879 /* else we're not dynamic and by definition we don't need such things. */
2881 /* The check_relocs and adjust_dynamic_symbol entry points have
2882 determined the sizes of the various dynamic sections. Allocate
2885 for (s = dynobj->sections; s != NULL; s = s->next)
2889 if (!(s->flags & SEC_LINKER_CREATED))
2892 /* It's OK to base decisions on the section name, because none
2893 of the dynobj section names depend upon the input files. */
2894 name = bfd_get_section_name (dynobj, s);
2896 if (CONST_STRNEQ (name, ".rela"))
2900 if (strcmp (name, ".rela.plt") == 0)
2903 /* We use the reloc_count field as a counter if we need
2904 to copy relocs into the output file. */
2908 else if (! CONST_STRNEQ (name, ".got")
2909 && strcmp (name, ".plt") != 0
2910 && strcmp (name, ".dynbss") != 0)
2912 /* It's not one of our dynamic sections, so don't allocate space. */
2918 /* If we don't need this section, strip it from the output file.
2919 This is to handle .rela.bss and .rela.plt. We must create it
2920 in create_dynamic_sections, because it must be created before
2921 the linker maps input sections to output sections. The
2922 linker does that before adjust_dynamic_symbol is called, and
2923 it is that function which decides whether anything needs to
2924 go into these sections. */
2925 if (!CONST_STRNEQ (name, ".got"))
2926 s->flags |= SEC_EXCLUDE;
2928 else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2930 /* Allocate memory for the section contents. */
2931 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2932 if (s->contents == NULL)
2937 if (elf_hash_table (info)->dynamic_sections_created)
2939 /* Add some entries to the .dynamic section. We fill in the
2940 values later, in elf64_alpha_finish_dynamic_sections, but we
2941 must add the entries now so that we get the correct size for
2942 the .dynamic section. The DT_DEBUG entry is filled in by the
2943 dynamic linker and used by the debugger. */
2944 #define add_dynamic_entry(TAG, VAL) \
2945 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2947 if (info->executable)
2949 if (!add_dynamic_entry (DT_DEBUG, 0))
2955 if (!add_dynamic_entry (DT_PLTGOT, 0)
2956 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2957 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2958 || !add_dynamic_entry (DT_JMPREL, 0))
2961 if (elf64_alpha_use_secureplt
2962 && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2966 if (!add_dynamic_entry (DT_RELA, 0)
2967 || !add_dynamic_entry (DT_RELASZ, 0)
2968 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2971 if (info->flags & DF_TEXTREL)
2973 if (!add_dynamic_entry (DT_TEXTREL, 0))
2977 #undef add_dynamic_entry
2982 /* These functions do relaxation for Alpha ELF.
2984 Currently I'm only handling what I can do with existing compiler
2985 and assembler support, which means no instructions are removed,
2986 though some may be nopped. At this time GCC does not emit enough
2987 information to do all of the relaxing that is possible. It will
2988 take some not small amount of work for that to happen.
2990 There are a couple of interesting papers that I once read on this
2991 subject, that I cannot find references to at the moment, that
2992 related to Alpha in particular. They are by David Wall, then of
2995 struct alpha_relax_info
3000 Elf_Internal_Shdr *symtab_hdr;
3001 Elf_Internal_Rela *relocs, *relend;
3002 struct bfd_link_info *link_info;
3006 struct alpha_elf_link_hash_entry *h;
3007 struct alpha_elf_got_entry **first_gotent;
3008 struct alpha_elf_got_entry *gotent;
3009 bfd_boolean changed_contents;
3010 bfd_boolean changed_relocs;
3011 unsigned char other;
3014 static Elf_Internal_Rela *
3015 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
3016 Elf_Internal_Rela *relend,
3017 bfd_vma offset, int type)
3019 while (rel < relend)
3021 if (rel->r_offset == offset
3022 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
3030 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3031 Elf_Internal_Rela *irel, unsigned long r_type)
3034 bfd_signed_vma disp;
3036 /* Get the instruction. */
3037 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3039 if (insn >> 26 != OP_LDQ)
3041 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3042 ((*_bfd_error_handler)
3043 ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
3044 info->abfd, info->sec,
3045 (unsigned long) irel->r_offset, howto->name));
3049 /* Can't relax dynamic symbols. */
3050 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3053 /* Can't use local-exec relocations in shared libraries. */
3054 if (r_type == R_ALPHA_GOTTPREL
3055 && (info->link_info->shared && !info->link_info->pie))
3058 if (r_type == R_ALPHA_LITERAL)
3060 /* Look for nice constant addresses. This includes the not-uncommon
3061 special case of 0 for undefweak symbols. */
3062 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3063 || (!info->link_info->shared
3064 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3067 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3068 insn |= (symval & 0xffff);
3069 r_type = R_ALPHA_NONE;
3073 disp = symval - info->gp;
3074 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3075 r_type = R_ALPHA_GPREL16;
3080 bfd_vma dtp_base, tp_base;
3082 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3083 dtp_base = alpha_get_dtprel_base (info->link_info);
3084 tp_base = alpha_get_tprel_base (info->link_info);
3085 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3087 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3091 case R_ALPHA_GOTDTPREL:
3092 r_type = R_ALPHA_DTPREL16;
3094 case R_ALPHA_GOTTPREL:
3095 r_type = R_ALPHA_TPREL16;
3103 if (disp < -0x8000 || disp >= 0x8000)
3106 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3107 info->changed_contents = TRUE;
3109 /* Reduce the use count on this got entry by one, possibly
3111 if (--info->gotent->use_count == 0)
3113 int sz = alpha_got_entry_size (r_type);
3114 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3116 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3119 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3120 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3121 info->changed_relocs = TRUE;
3123 /* ??? Search forward through this basic block looking for insns
3124 that use the target register. Stop after an insn modifying the
3125 register is seen, or after a branch or call.
3127 Any such memory load insn may be substituted by a load directly
3128 off the GP. This allows the memory load insn to be issued before
3129 the calculated GP register would otherwise be ready.
3131 Any such jsr insn can be replaced by a bsr if it is in range.
3133 This would mean that we'd have to _add_ relocations, the pain of
3134 which gives one pause. */
3140 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3142 /* If the function has the same gp, and we can identify that the
3143 function does not use its function pointer, we can eliminate the
3146 /* If the symbol is marked NOPV, we are being told the function never
3147 needs its procedure value. */
3148 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3151 /* If the symbol is marked STD_GP, we are being told the function does
3152 a normal ldgp in the first two words. */
3153 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3156 /* Otherwise, we may be able to identify a GP load in the first two
3157 words, which we can then skip. */
3160 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3163 /* Load the relocations from the section that the target symbol is in. */
3164 if (info->sec == info->tsec)
3166 tsec_relocs = info->relocs;
3167 tsec_relend = info->relend;
3172 tsec_relocs = (_bfd_elf_link_read_relocs
3173 (info->abfd, info->tsec, (PTR) NULL,
3174 (Elf_Internal_Rela *) NULL,
3175 info->link_info->keep_memory));
3176 if (tsec_relocs == NULL)
3178 tsec_relend = tsec_relocs + info->tsec->reloc_count;
3179 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
3182 /* Recover the symbol's offset within the section. */
3183 ofs = (symval - info->tsec->output_section->vma
3184 - info->tsec->output_offset);
3186 /* Look for a GPDISP reloc. */
3187 gpdisp = (elf64_alpha_find_reloc_at_ofs
3188 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3190 if (!gpdisp || gpdisp->r_addend != 4)
3200 /* We've now determined that we can skip an initial gp load. Verify
3201 that the call and the target use the same gp. */
3202 if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3203 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3210 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3211 bfd_vma symval, Elf_Internal_Rela *irel)
3213 Elf_Internal_Rela *urel, *irelend = info->relend;
3214 int flags, count, i;
3215 bfd_signed_vma disp;
3218 bfd_boolean lit_reused = FALSE;
3219 bfd_boolean all_optimized = TRUE;
3220 unsigned int lit_insn;
3222 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3223 if (lit_insn >> 26 != OP_LDQ)
3225 ((*_bfd_error_handler)
3226 ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
3227 info->abfd, info->sec,
3228 (unsigned long) irel->r_offset));
3232 /* Can't relax dynamic symbols. */
3233 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3236 /* Summarize how this particular LITERAL is used. */
3237 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
3239 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
3241 if (urel->r_addend <= 6)
3242 flags |= 1 << urel->r_addend;
3245 /* A little preparation for the loop... */
3246 disp = symval - info->gp;
3248 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
3252 bfd_signed_vma xdisp;
3254 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
3256 switch (urel->r_addend)
3258 case LITUSE_ALPHA_ADDR:
3260 /* This type is really just a placeholder to note that all
3261 uses cannot be optimized, but to still allow some. */
3262 all_optimized = FALSE;
3265 case LITUSE_ALPHA_BASE:
3266 /* We can always optimize 16-bit displacements. */
3268 /* Extract the displacement from the instruction, sign-extending
3269 it if necessary, then test whether it is within 16 or 32 bits
3270 displacement from GP. */
3271 insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3273 xdisp = disp + insn_disp;
3274 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3275 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3276 && xdisp < 0x7fff8000);
3280 /* Take the op code and dest from this insn, take the base
3281 register from the literal insn. Leave the offset alone. */
3282 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3283 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3285 urel->r_addend = irel->r_addend;
3286 info->changed_relocs = TRUE;
3288 bfd_put_32 (info->abfd, (bfd_vma) insn,
3289 info->contents + urel->r_offset);
3290 info->changed_contents = TRUE;
3293 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3294 else if (fits32 && !(flags & ~6))
3296 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3298 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3300 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3301 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
3302 info->contents + irel->r_offset);
3304 info->changed_contents = TRUE;
3306 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3308 urel->r_addend = irel->r_addend;
3309 info->changed_relocs = TRUE;
3312 all_optimized = FALSE;
3315 case LITUSE_ALPHA_BYTOFF:
3316 /* We can always optimize byte instructions. */
3318 /* FIXME: sanity check the insn for byte op. Check that the
3319 literal dest reg is indeed Rb in the byte insn. */
3321 insn &= ~ (unsigned) 0x001ff000;
3322 insn |= ((symval & 7) << 13) | 0x1000;
3324 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3326 info->changed_relocs = TRUE;
3328 bfd_put_32 (info->abfd, (bfd_vma) insn,
3329 info->contents + urel->r_offset);
3330 info->changed_contents = TRUE;
3333 case LITUSE_ALPHA_JSR:
3334 case LITUSE_ALPHA_TLSGD:
3335 case LITUSE_ALPHA_TLSLDM:
3336 case LITUSE_ALPHA_JSRDIRECT:
3338 bfd_vma optdest, org;
3339 bfd_signed_vma odisp;
3341 /* For undefined weak symbols, we're mostly interested in getting
3342 rid of the got entry whenever possible, so optimize this to a
3343 use of the zero register. */
3344 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3347 bfd_put_32 (info->abfd, (bfd_vma) insn,
3348 info->contents + urel->r_offset);
3350 info->changed_contents = TRUE;
3354 /* If not zero, place to jump without needing pv. */
3355 optdest = elf64_alpha_relax_opt_call (info, symval);
3356 org = (info->sec->output_section->vma
3357 + info->sec->output_offset
3358 + urel->r_offset + 4);
3359 odisp = (optdest ? optdest : symval) - org;
3361 if (odisp >= -0x400000 && odisp < 0x400000)
3363 Elf_Internal_Rela *xrel;
3365 /* Preserve branch prediction call stack when possible. */
3366 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3367 insn = (OP_BSR << 26) | (insn & 0x03e00000);
3369 insn = (OP_BR << 26) | (insn & 0x03e00000);
3371 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3373 urel->r_addend = irel->r_addend;
3376 urel->r_addend += optdest - symval;
3378 all_optimized = FALSE;
3380 bfd_put_32 (info->abfd, (bfd_vma) insn,
3381 info->contents + urel->r_offset);
3383 /* Kill any HINT reloc that might exist for this insn. */
3384 xrel = (elf64_alpha_find_reloc_at_ofs
3385 (info->relocs, info->relend, urel->r_offset,
3388 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3390 info->changed_contents = TRUE;
3391 info->changed_relocs = TRUE;
3394 all_optimized = FALSE;
3396 /* Even if the target is not in range for a direct branch,
3397 if we share a GP, we can eliminate the gp reload. */
3400 Elf_Internal_Rela *gpdisp
3401 = (elf64_alpha_find_reloc_at_ofs
3402 (info->relocs, irelend, urel->r_offset + 4,
3406 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
3407 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3408 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
3409 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
3411 /* Verify that the instruction is "ldah $29,0($26)".
3412 Consider a function that ends in a noreturn call,
3413 and that the next function begins with an ldgp,
3414 and that by accident there is no padding between.
3415 In that case the insn would use $27 as the base. */
3416 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3418 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
3419 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
3421 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3422 info->changed_contents = TRUE;
3423 info->changed_relocs = TRUE;
3432 /* If all cases were optimized, we can reduce the use count on this
3433 got entry by one, possibly eliminating it. */
3436 if (--info->gotent->use_count == 0)
3438 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3439 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3441 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3444 /* If the literal instruction is no longer needed (it may have been
3445 reused. We can eliminate it. */
3446 /* ??? For now, I don't want to deal with compacting the section,
3447 so just nop it out. */
3450 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3451 info->changed_relocs = TRUE;
3453 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
3454 info->contents + irel->r_offset);
3455 info->changed_contents = TRUE;
3461 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3465 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3466 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3469 unsigned int insn, tlsgd_reg;
3470 Elf_Internal_Rela *gpdisp, *hint;
3471 bfd_boolean dynamic, use_gottprel;
3472 unsigned long new_symndx;
3474 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3476 /* If a TLS symbol is accessed using IE at least once, there is no point
3477 to use dynamic model for it. */
3478 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3481 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3482 then we might as well relax to IE. */
3483 else if (info->link_info->shared && !dynamic
3484 && (info->link_info->flags & DF_STATIC_TLS))
3487 /* Otherwise we must be building an executable to do anything. */
3488 else if (info->link_info->shared)
3491 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3492 the matching LITUSE_TLS relocations. */
3493 if (irel + 2 >= info->relend)
3495 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3496 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3497 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3500 /* There must be a GPDISP relocation positioned immediately after the
3501 LITUSE relocation. */
3502 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3503 irel[2].r_offset + 4, R_ALPHA_GPDISP);
3507 pos[0] = info->contents + irel[0].r_offset;
3508 pos[1] = info->contents + irel[1].r_offset;
3509 pos[2] = info->contents + irel[2].r_offset;
3510 pos[3] = info->contents + gpdisp->r_offset;
3511 pos[4] = pos[3] + gpdisp->r_addend;
3513 /* Beware of the compiler hoisting part of the sequence out a loop
3514 and adjusting the destination register for the TLSGD insn. If this
3515 happens, there will be a move into $16 before the JSR insn, so only
3516 transformations of the first insn pair should use this register. */
3517 tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3518 tlsgd_reg = (tlsgd_reg >> 21) & 31;
3520 /* Generally, the positions are not allowed to be out of order, lest the
3521 modified insn sequence have different register lifetimes. We can make
3522 an exception when pos 1 is adjacent to pos 0. */
3523 if (pos[1] + 4 == pos[0])
3525 bfd_byte *tmp = pos[0];
3529 if (pos[1] >= pos[2] || pos[2] >= pos[3])
3532 /* Reduce the use count on the LITERAL relocation. Do this before we
3533 smash the symndx when we adjust the relocations below. */
3535 struct alpha_elf_got_entry *lit_gotent;
3536 struct alpha_elf_link_hash_entry *lit_h;
3539 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3540 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3541 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3543 while (lit_h->root.root.type == bfd_link_hash_indirect
3544 || lit_h->root.root.type == bfd_link_hash_warning)
3545 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3547 for (lit_gotent = lit_h->got_entries; lit_gotent ;
3548 lit_gotent = lit_gotent->next)
3549 if (lit_gotent->gotobj == info->gotobj
3550 && lit_gotent->reloc_type == R_ALPHA_LITERAL
3551 && lit_gotent->addend == irel[1].r_addend)
3553 BFD_ASSERT (lit_gotent);
3555 if (--lit_gotent->use_count == 0)
3557 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3558 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3564 lda $16,x($gp) !tlsgd!1
3565 ldq $27,__tls_get_addr($gp) !literal!1
3566 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3567 ldah $29,0($26) !gpdisp!2
3568 lda $29,0($29) !gpdisp!2
3570 ldq $16,x($gp) !gottprel
3575 or the first pair to
3576 lda $16,x($gp) !tprel
3579 ldah $16,x($gp) !tprelhi
3580 lda $16,x($16) !tprello
3584 use_gottprel = FALSE;
3585 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3587 switch (!dynamic && !info->link_info->shared)
3592 bfd_signed_vma disp;
3594 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3595 tp_base = alpha_get_tprel_base (info->link_info);
3596 disp = symval - tp_base;
3598 if (disp >= -0x8000 && disp < 0x8000)
3600 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3601 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3602 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3604 irel[0].r_offset = pos[0] - info->contents;
3605 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3606 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3609 else if (disp >= -(bfd_signed_vma) 0x80000000
3610 && disp < (bfd_signed_vma) 0x7fff8000
3611 && pos[0] + 4 == pos[1])
3613 insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3614 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3615 insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3616 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3618 irel[0].r_offset = pos[0] - info->contents;
3619 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3620 irel[1].r_offset = pos[1] - info->contents;
3621 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3628 use_gottprel = TRUE;
3630 insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3631 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3632 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3634 irel[0].r_offset = pos[0] - info->contents;
3635 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3636 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3640 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3642 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3643 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3645 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3647 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3648 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3650 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3651 irel[2].r_offset, R_ALPHA_HINT);
3653 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3655 info->changed_contents = TRUE;
3656 info->changed_relocs = TRUE;
3658 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3659 if (--info->gotent->use_count == 0)
3661 int sz = alpha_got_entry_size (info->gotent->reloc_type);
3662 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3664 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3667 /* If we've switched to a GOTTPREL relocation, increment the reference
3668 count on that got entry. */
3671 struct alpha_elf_got_entry *tprel_gotent;
3673 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3674 tprel_gotent = tprel_gotent->next)
3675 if (tprel_gotent->gotobj == info->gotobj
3676 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3677 && tprel_gotent->addend == irel->r_addend)
3680 tprel_gotent->use_count++;
3683 if (info->gotent->use_count == 0)
3684 tprel_gotent = info->gotent;
3687 tprel_gotent = (struct alpha_elf_got_entry *)
3688 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3692 tprel_gotent->next = *info->first_gotent;
3693 *info->first_gotent = tprel_gotent;
3695 tprel_gotent->gotobj = info->gotobj;
3696 tprel_gotent->addend = irel->r_addend;
3697 tprel_gotent->got_offset = -1;
3698 tprel_gotent->reloc_done = 0;
3699 tprel_gotent->reloc_xlated = 0;
3702 tprel_gotent->use_count = 1;
3703 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3711 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3712 struct bfd_link_info *link_info, bfd_boolean *again)
3714 Elf_Internal_Shdr *symtab_hdr;
3715 Elf_Internal_Rela *internal_relocs;
3716 Elf_Internal_Rela *irel, *irelend;
3717 Elf_Internal_Sym *isymbuf = NULL;
3718 struct alpha_elf_got_entry **local_got_entries;
3719 struct alpha_relax_info info;
3720 struct alpha_elf_link_hash_table * htab;
3722 htab = alpha_elf_hash_table (link_info);
3726 /* There's nothing to change, yet. */
3729 if (link_info->relocatable
3730 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3731 != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3732 || sec->reloc_count == 0)
3735 BFD_ASSERT (is_alpha_elf (abfd));
3737 /* Make sure our GOT and PLT tables are up-to-date. */
3738 if (htab->relax_trip != link_info->relax_trip)
3740 htab->relax_trip = link_info->relax_trip;
3742 /* This should never fail after the initial round, since the only
3743 error is GOT overflow, and relaxation only shrinks the table. */
3744 if (!elf64_alpha_size_got_sections (link_info))
3746 if (elf_hash_table (link_info)->dynamic_sections_created)
3748 elf64_alpha_size_plt_section (link_info);
3749 elf64_alpha_size_rela_got_section (link_info);
3753 symtab_hdr = &elf_symtab_hdr (abfd);
3754 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3756 /* Load the relocations for this section. */
3757 internal_relocs = (_bfd_elf_link_read_relocs
3758 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
3759 link_info->keep_memory));
3760 if (internal_relocs == NULL)
3763 memset(&info, 0, sizeof (info));
3766 info.link_info = link_info;
3767 info.symtab_hdr = symtab_hdr;
3768 info.relocs = internal_relocs;
3769 info.relend = irelend = internal_relocs + sec->reloc_count;
3771 /* Find the GP for this object. Do not store the result back via
3772 _bfd_set_gp_value, since this could change again before final. */
3773 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3776 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3777 info.gp = (sgot->output_section->vma
3778 + sgot->output_offset
3782 /* Get the section contents. */
3783 if (elf_section_data (sec)->this_hdr.contents != NULL)
3784 info.contents = elf_section_data (sec)->this_hdr.contents;
3787 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3791 for (irel = internal_relocs; irel < irelend; irel++)
3794 struct alpha_elf_got_entry *gotent;
3795 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3796 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3798 /* Early exit for unhandled or unrelaxable relocations. */
3801 case R_ALPHA_LITERAL:
3802 case R_ALPHA_GPRELHIGH:
3803 case R_ALPHA_GPRELLOW:
3804 case R_ALPHA_GOTDTPREL:
3805 case R_ALPHA_GOTTPREL:
3809 case R_ALPHA_TLSLDM:
3810 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3811 reloc to the STN_UNDEF (0) symbol so that they all match. */
3812 r_symndx = STN_UNDEF;
3819 /* Get the value of the symbol referred to by the reloc. */
3820 if (r_symndx < symtab_hdr->sh_info)
3822 /* A local symbol. */
3823 Elf_Internal_Sym *isym;
3825 /* Read this BFD's local symbols. */
3826 if (isymbuf == NULL)
3828 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3829 if (isymbuf == NULL)
3830 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3831 symtab_hdr->sh_info, 0,
3833 if (isymbuf == NULL)
3837 isym = isymbuf + r_symndx;
3839 /* Given the symbol for a TLSLDM reloc is ignored, this also
3840 means forcing the symbol value to the tp base. */
3841 if (r_type == R_ALPHA_TLSLDM)
3843 info.tsec = bfd_abs_section_ptr;
3844 symval = alpha_get_tprel_base (info.link_info);
3848 symval = isym->st_value;
3849 if (isym->st_shndx == SHN_UNDEF)
3851 else if (isym->st_shndx == SHN_ABS)
3852 info.tsec = bfd_abs_section_ptr;
3853 else if (isym->st_shndx == SHN_COMMON)
3854 info.tsec = bfd_com_section_ptr;
3856 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3860 info.other = isym->st_other;
3861 if (local_got_entries)
3862 info.first_gotent = &local_got_entries[r_symndx];
3865 info.first_gotent = &info.gotent;
3872 struct alpha_elf_link_hash_entry *h;
3874 indx = r_symndx - symtab_hdr->sh_info;
3875 h = alpha_elf_sym_hashes (abfd)[indx];
3876 BFD_ASSERT (h != NULL);
3878 while (h->root.root.type == bfd_link_hash_indirect
3879 || h->root.root.type == bfd_link_hash_warning)
3880 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3882 /* If the symbol is undefined, we can't do anything with it. */
3883 if (h->root.root.type == bfd_link_hash_undefined)
3886 /* If the symbol isn't defined in the current module,
3887 again we can't do anything. */
3888 if (h->root.root.type == bfd_link_hash_undefweak)
3890 info.tsec = bfd_abs_section_ptr;
3893 else if (!h->root.def_regular)
3895 /* Except for TLSGD relocs, which can sometimes be
3896 relaxed to GOTTPREL relocs. */
3897 if (r_type != R_ALPHA_TLSGD)
3899 info.tsec = bfd_abs_section_ptr;
3904 info.tsec = h->root.root.u.def.section;
3905 symval = h->root.root.u.def.value;
3909 info.other = h->root.other;
3910 info.first_gotent = &h->got_entries;
3913 /* Search for the got entry to be used by this relocation. */
3914 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3915 if (gotent->gotobj == info.gotobj
3916 && gotent->reloc_type == r_type
3917 && gotent->addend == irel->r_addend)
3919 info.gotent = gotent;
3921 symval += info.tsec->output_section->vma + info.tsec->output_offset;
3922 symval += irel->r_addend;
3926 case R_ALPHA_LITERAL:
3927 BFD_ASSERT(info.gotent != NULL);
3929 /* If there exist LITUSE relocations immediately following, this
3930 opens up all sorts of interesting optimizations, because we
3931 now know every location that this address load is used. */
3932 if (irel+1 < irelend
3933 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
3935 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
3940 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3945 case R_ALPHA_GOTDTPREL:
3946 case R_ALPHA_GOTTPREL:
3947 BFD_ASSERT(info.gotent != NULL);
3948 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3953 case R_ALPHA_TLSLDM:
3954 BFD_ASSERT(info.gotent != NULL);
3955 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
3956 r_type == R_ALPHA_TLSGD))
3963 && symtab_hdr->contents != (unsigned char *) isymbuf)
3965 if (!link_info->keep_memory)
3969 /* Cache the symbols for elf_link_input_bfd. */
3970 symtab_hdr->contents = (unsigned char *) isymbuf;
3974 if (info.contents != NULL
3975 && elf_section_data (sec)->this_hdr.contents != info.contents)
3977 if (!info.changed_contents && !link_info->keep_memory)
3978 free (info.contents);
3981 /* Cache the section contents for elf_link_input_bfd. */
3982 elf_section_data (sec)->this_hdr.contents = info.contents;
3986 if (elf_section_data (sec)->relocs != internal_relocs)
3988 if (!info.changed_relocs)
3989 free (internal_relocs);
3991 elf_section_data (sec)->relocs = internal_relocs;
3994 *again = info.changed_contents || info.changed_relocs;
4000 && symtab_hdr->contents != (unsigned char *) isymbuf)
4002 if (info.contents != NULL
4003 && elf_section_data (sec)->this_hdr.contents != info.contents)
4004 free (info.contents);
4005 if (internal_relocs != NULL
4006 && elf_section_data (sec)->relocs != internal_relocs)
4007 free (internal_relocs);
4011 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4012 into the next available slot in SREL. */
4015 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4016 asection *sec, asection *srel, bfd_vma offset,
4017 long dynindx, long rtype, bfd_vma addend)
4019 Elf_Internal_Rela outrel;
4022 BFD_ASSERT (srel != NULL);
4024 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4025 outrel.r_addend = addend;
4027 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4028 if ((offset | 1) != (bfd_vma) -1)
4029 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4031 memset (&outrel, 0, sizeof (outrel));
4033 loc = srel->contents;
4034 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4035 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4036 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4039 /* Relocate an Alpha ELF section for a relocatable link.
4041 We don't have to change anything unless the reloc is against a section
4042 symbol, in which case we have to adjust according to where the section
4043 symbol winds up in the output section. */
4046 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4047 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4048 bfd *input_bfd, asection *input_section,
4049 bfd_byte *contents ATTRIBUTE_UNUSED,
4050 Elf_Internal_Rela *relocs,
4051 Elf_Internal_Sym *local_syms,
4052 asection **local_sections)
4054 unsigned long symtab_hdr_sh_info;
4055 Elf_Internal_Rela *rel;
4056 Elf_Internal_Rela *relend;
4057 struct elf_link_hash_entry **sym_hashes;
4058 bfd_boolean ret_val = TRUE;
4060 symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4061 sym_hashes = elf_sym_hashes (input_bfd);
4063 relend = relocs + input_section->reloc_count;
4064 for (rel = relocs; rel < relend; rel++)
4066 unsigned long r_symndx;
4067 Elf_Internal_Sym *sym;
4069 unsigned long r_type;
4071 r_type = ELF64_R_TYPE (rel->r_info);
4072 if (r_type >= R_ALPHA_max)
4074 (*_bfd_error_handler)
4075 (_("%B: unknown relocation type %d"),
4076 input_bfd, (int) r_type);
4077 bfd_set_error (bfd_error_bad_value);
4082 /* The symbol associated with GPDISP and LITUSE is
4083 immaterial. Only the addend is significant. */
4084 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4087 r_symndx = ELF64_R_SYM (rel->r_info);
4088 if (r_symndx < symtab_hdr_sh_info)
4090 sym = local_syms + r_symndx;
4091 sec = local_sections[r_symndx];
4095 struct elf_link_hash_entry *h;
4097 h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4099 while (h->root.type == bfd_link_hash_indirect
4100 || h->root.type == bfd_link_hash_warning)
4101 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4103 if (h->root.type != bfd_link_hash_defined
4104 && h->root.type != bfd_link_hash_defweak)
4108 sec = h->root.u.def.section;
4111 if (sec != NULL && discarded_section (sec))
4112 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4114 elf64_alpha_howto_table + r_type,
4117 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4118 rel->r_addend += sec->output_offset;
4124 /* Relocate an Alpha ELF section. */
4127 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4128 bfd *input_bfd, asection *input_section,
4129 bfd_byte *contents, Elf_Internal_Rela *relocs,
4130 Elf_Internal_Sym *local_syms,
4131 asection **local_sections)
4133 Elf_Internal_Shdr *symtab_hdr;
4134 Elf_Internal_Rela *rel;
4135 Elf_Internal_Rela *relend;
4136 asection *sgot, *srel, *srelgot;
4137 bfd *dynobj, *gotobj;
4138 bfd_vma gp, tp_base, dtp_base;
4139 struct alpha_elf_got_entry **local_got_entries;
4140 bfd_boolean ret_val;
4142 BFD_ASSERT (is_alpha_elf (input_bfd));
4144 /* Handle relocatable links with a smaller loop. */
4145 if (info->relocatable)
4146 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4147 input_section, contents, relocs,
4148 local_syms, local_sections);
4150 /* This is a final link. */
4154 symtab_hdr = &elf_symtab_hdr (input_bfd);
4156 dynobj = elf_hash_table (info)->dynobj;
4158 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4162 if (input_section->flags & SEC_ALLOC)
4164 const char *section_name;
4165 section_name = (bfd_elf_string_from_elf_section
4166 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4167 _bfd_elf_single_rel_hdr (input_section)->sh_name));
4168 BFD_ASSERT(section_name != NULL);
4169 srel = bfd_get_section_by_name (dynobj, section_name);
4174 /* Find the gp value for this input bfd. */
4175 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4178 sgot = alpha_elf_tdata (gotobj)->got;
4179 gp = _bfd_get_gp_value (gotobj);
4182 gp = (sgot->output_section->vma
4183 + sgot->output_offset
4185 _bfd_set_gp_value (gotobj, gp);
4194 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4196 if (elf_hash_table (info)->tls_sec != NULL)
4198 dtp_base = alpha_get_dtprel_base (info);
4199 tp_base = alpha_get_tprel_base (info);
4202 dtp_base = tp_base = 0;
4204 relend = relocs + input_section->reloc_count;
4205 for (rel = relocs; rel < relend; rel++)
4207 struct alpha_elf_link_hash_entry *h = NULL;
4208 struct alpha_elf_got_entry *gotent;
4209 bfd_reloc_status_type r;
4210 reloc_howto_type *howto;
4211 unsigned long r_symndx;
4212 Elf_Internal_Sym *sym = NULL;
4213 asection *sec = NULL;
4216 bfd_boolean dynamic_symbol_p;
4217 bfd_boolean unresolved_reloc = FALSE;
4218 bfd_boolean undef_weak_ref = FALSE;
4219 unsigned long r_type;
4221 r_type = ELF64_R_TYPE(rel->r_info);
4222 if (r_type >= R_ALPHA_max)
4224 (*_bfd_error_handler)
4225 (_("%B: unknown relocation type %d"),
4226 input_bfd, (int) r_type);
4227 bfd_set_error (bfd_error_bad_value);
4232 howto = elf64_alpha_howto_table + r_type;
4233 r_symndx = ELF64_R_SYM(rel->r_info);
4235 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4236 reloc to the STN_UNDEF (0) symbol so that they all match. */
4237 if (r_type == R_ALPHA_TLSLDM)
4238 r_symndx = STN_UNDEF;
4240 if (r_symndx < symtab_hdr->sh_info)
4243 sym = local_syms + r_symndx;
4244 sec = local_sections[r_symndx];
4246 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4248 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4249 this is hackery from relax_section. Force the value to
4250 be the tls module base. */
4251 if (r_symndx == STN_UNDEF
4252 && (r_type == R_ALPHA_TLSLDM
4253 || r_type == R_ALPHA_GOTTPREL
4254 || r_type == R_ALPHA_TPREL64
4255 || r_type == R_ALPHA_TPRELHI
4256 || r_type == R_ALPHA_TPRELLO
4257 || r_type == R_ALPHA_TPREL16))
4260 if (local_got_entries)
4261 gotent = local_got_entries[r_symndx];
4265 /* Need to adjust local GOT entries' addends for SEC_MERGE
4266 unless it has been done already. */
4267 if ((sec->flags & SEC_MERGE)
4268 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4269 && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4271 && !gotent->reloc_xlated)
4273 struct alpha_elf_got_entry *ent;
4275 for (ent = gotent; ent; ent = ent->next)
4277 ent->reloc_xlated = 1;
4278 if (ent->use_count == 0)
4282 _bfd_merged_section_offset (output_bfd, &msec,
4283 elf_section_data (sec)->
4285 sym->st_value + ent->addend);
4286 ent->addend -= sym->st_value;
4287 ent->addend += msec->output_section->vma
4288 + msec->output_offset
4289 - sec->output_section->vma
4290 - sec->output_offset;
4294 dynamic_symbol_p = FALSE;
4299 struct elf_link_hash_entry *hh;
4300 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4302 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4303 r_symndx, symtab_hdr, sym_hashes,
4305 unresolved_reloc, warned);
4311 && ! unresolved_reloc
4312 && hh->root.type == bfd_link_hash_undefweak)
4313 undef_weak_ref = TRUE;
4315 h = (struct alpha_elf_link_hash_entry *) hh;
4316 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4317 gotent = h->got_entries;
4320 if (sec != NULL && discarded_section (sec))
4321 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4322 rel, relend, howto, contents);
4324 addend = rel->r_addend;
4327 /* Search for the proper got entry. */
4328 for (; gotent ; gotent = gotent->next)
4329 if (gotent->gotobj == gotobj
4330 && gotent->reloc_type == r_type
4331 && gotent->addend == addend)
4336 case R_ALPHA_GPDISP:
4338 bfd_byte *p_ldah, *p_lda;
4340 BFD_ASSERT(gp != 0);
4342 value = (input_section->output_section->vma
4343 + input_section->output_offset
4346 p_ldah = contents + rel->r_offset;
4347 p_lda = p_ldah + rel->r_addend;
4349 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4354 case R_ALPHA_LITERAL:
4355 BFD_ASSERT(sgot != NULL);
4356 BFD_ASSERT(gp != 0);
4357 BFD_ASSERT(gotent != NULL);
4358 BFD_ASSERT(gotent->use_count >= 1);
4360 if (!gotent->reloc_done)
4362 gotent->reloc_done = 1;
4364 bfd_put_64 (output_bfd, value,
4365 sgot->contents + gotent->got_offset);
4367 /* If the symbol has been forced local, output a
4368 RELATIVE reloc, otherwise it will be handled in
4369 finish_dynamic_symbol. */
4370 if (info->shared && !dynamic_symbol_p && !undef_weak_ref)
4371 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4372 gotent->got_offset, 0,
4373 R_ALPHA_RELATIVE, value);
4376 value = (sgot->output_section->vma
4377 + sgot->output_offset
4378 + gotent->got_offset);
4382 case R_ALPHA_GPREL32:
4383 case R_ALPHA_GPREL16:
4384 case R_ALPHA_GPRELLOW:
4385 if (dynamic_symbol_p)
4387 (*_bfd_error_handler)
4388 (_("%B: gp-relative relocation against dynamic symbol %s"),
4389 input_bfd, h->root.root.root.string);
4392 BFD_ASSERT(gp != 0);
4396 case R_ALPHA_GPRELHIGH:
4397 if (dynamic_symbol_p)
4399 (*_bfd_error_handler)
4400 (_("%B: gp-relative relocation against dynamic symbol %s"),
4401 input_bfd, h->root.root.root.string);
4404 BFD_ASSERT(gp != 0);
4406 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4410 /* A call to a dynamic symbol is definitely out of range of
4411 the 16-bit displacement. Don't bother writing anything. */
4412 if (dynamic_symbol_p)
4417 /* The regular PC-relative stuff measures from the start of
4418 the instruction rather than the end. */
4422 case R_ALPHA_BRADDR:
4423 if (dynamic_symbol_p)
4425 (*_bfd_error_handler)
4426 (_("%B: pc-relative relocation against dynamic symbol %s"),
4427 input_bfd, h->root.root.root.string);
4430 /* The regular PC-relative stuff measures from the start of
4431 the instruction rather than the end. */
4440 /* The regular PC-relative stuff measures from the start of
4441 the instruction rather than the end. */
4444 /* The source and destination gp must be the same. Note that
4445 the source will always have an assigned gp, since we forced
4446 one in check_relocs, but that the destination may not, as
4447 it might not have had any relocations at all. Also take
4448 care not to crash if H is an undefined symbol. */
4449 if (h != NULL && sec != NULL
4450 && alpha_elf_tdata (sec->owner)->gotobj
4451 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4453 (*_bfd_error_handler)
4454 (_("%B: change in gp: BRSGP %s"),
4455 input_bfd, h->root.root.root.string);
4459 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4461 other = h->root.other;
4463 other = sym->st_other;
4464 switch (other & STO_ALPHA_STD_GPLOAD)
4466 case STO_ALPHA_NOPV:
4468 case STO_ALPHA_STD_GPLOAD:
4473 name = h->root.root.root.string;
4476 name = (bfd_elf_string_from_elf_section
4477 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4479 name = _("<unknown>");
4480 else if (name[0] == 0)
4481 name = bfd_section_name (input_bfd, sec);
4483 (*_bfd_error_handler)
4484 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4493 case R_ALPHA_REFLONG:
4494 case R_ALPHA_REFQUAD:
4495 case R_ALPHA_DTPREL64:
4496 case R_ALPHA_TPREL64:
4498 long dynindx, dyntype = r_type;
4501 /* Careful here to remember RELATIVE relocations for global
4502 variables for symbolic shared objects. */
4504 if (dynamic_symbol_p)
4506 BFD_ASSERT(h->root.dynindx != -1);
4507 dynindx = h->root.dynindx;
4509 addend = 0, value = 0;
4511 else if (r_type == R_ALPHA_DTPREL64)
4513 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4517 else if (r_type == R_ALPHA_TPREL64)
4519 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4520 if (!info->shared || info->pie)
4526 dynaddend = value - dtp_base;
4528 else if (info->shared
4529 && r_symndx != STN_UNDEF
4530 && (input_section->flags & SEC_ALLOC)
4532 && !(unresolved_reloc
4533 && (_bfd_elf_section_offset (output_bfd, info,
4538 if (r_type == R_ALPHA_REFLONG)
4540 (*_bfd_error_handler)
4541 (_("%B: unhandled dynamic relocation against %s"),
4543 h->root.root.root.string);
4547 dyntype = R_ALPHA_RELATIVE;
4553 if (input_section->flags & SEC_ALLOC)
4554 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4555 srel, rel->r_offset, dynindx,
4556 dyntype, dynaddend);
4560 case R_ALPHA_SREL16:
4561 case R_ALPHA_SREL32:
4562 case R_ALPHA_SREL64:
4563 if (dynamic_symbol_p)
4565 (*_bfd_error_handler)
4566 (_("%B: pc-relative relocation against dynamic symbol %s"),
4567 input_bfd, h->root.root.root.string);
4570 else if ((info->shared || info->pie) && undef_weak_ref)
4572 (*_bfd_error_handler)
4573 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4574 input_bfd, h->root.root.root.string);
4579 /* ??? .eh_frame references to discarded sections will be smashed
4580 to relocations against SHN_UNDEF. The .eh_frame format allows
4581 NULL to be encoded as 0 in any format, so this works here. */
4582 if (r_symndx == STN_UNDEF
4583 || (unresolved_reloc
4584 && _bfd_elf_section_offset (output_bfd, info,
4586 rel->r_offset) == (bfd_vma) -1))
4587 howto = (elf64_alpha_howto_table
4588 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4591 case R_ALPHA_TLSLDM:
4592 /* Ignore the symbol for the relocation. The result is always
4593 the current module. */
4594 dynamic_symbol_p = 0;
4598 if (!gotent->reloc_done)
4600 gotent->reloc_done = 1;
4602 /* Note that the module index for the main program is 1. */
4603 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4604 sgot->contents + gotent->got_offset);
4606 /* If the symbol has been forced local, output a
4607 DTPMOD64 reloc, otherwise it will be handled in
4608 finish_dynamic_symbol. */
4609 if (info->shared && !dynamic_symbol_p)
4610 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4611 gotent->got_offset, 0,
4612 R_ALPHA_DTPMOD64, 0);
4614 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4618 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4621 bfd_put_64 (output_bfd, value,
4622 sgot->contents + gotent->got_offset + 8);
4625 value = (sgot->output_section->vma
4626 + sgot->output_offset
4627 + gotent->got_offset);
4631 case R_ALPHA_DTPRELHI:
4632 case R_ALPHA_DTPRELLO:
4633 case R_ALPHA_DTPREL16:
4634 if (dynamic_symbol_p)
4636 (*_bfd_error_handler)
4637 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4638 input_bfd, h->root.root.root.string);
4641 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4643 if (r_type == R_ALPHA_DTPRELHI)
4644 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4647 case R_ALPHA_TPRELHI:
4648 case R_ALPHA_TPRELLO:
4649 case R_ALPHA_TPREL16:
4650 if (info->shared && !info->pie)
4652 (*_bfd_error_handler)
4653 (_("%B: TLS local exec code cannot be linked into shared objects"),
4657 else if (dynamic_symbol_p)
4659 (*_bfd_error_handler)
4660 (_("%B: tp-relative relocation against dynamic symbol %s"),
4661 input_bfd, h->root.root.root.string);
4664 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4666 if (r_type == R_ALPHA_TPRELHI)
4667 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4670 case R_ALPHA_GOTDTPREL:
4671 case R_ALPHA_GOTTPREL:
4672 BFD_ASSERT(sgot != NULL);
4673 BFD_ASSERT(gp != 0);
4674 BFD_ASSERT(gotent != NULL);
4675 BFD_ASSERT(gotent->use_count >= 1);
4677 if (!gotent->reloc_done)
4679 gotent->reloc_done = 1;
4681 if (dynamic_symbol_p)
4685 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4686 if (r_type == R_ALPHA_GOTDTPREL)
4688 else if (!info->shared)
4692 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4693 gotent->got_offset, 0,
4699 bfd_put_64 (output_bfd, value,
4700 sgot->contents + gotent->got_offset);
4703 value = (sgot->output_section->vma
4704 + sgot->output_offset
4705 + gotent->got_offset);
4711 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4712 contents, rel->r_offset, value, 0);
4721 case bfd_reloc_overflow:
4725 /* Don't warn if the overflow is due to pc relative reloc
4726 against discarded section. Section optimization code should
4729 if (r_symndx < symtab_hdr->sh_info
4730 && sec != NULL && howto->pc_relative
4731 && discarded_section (sec))
4738 name = (bfd_elf_string_from_elf_section
4739 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4743 name = bfd_section_name (input_bfd, sec);
4745 if (! ((*info->callbacks->reloc_overflow)
4746 (info, (h ? &h->root.root : NULL), name, howto->name,
4747 (bfd_vma) 0, input_bfd, input_section,
4754 case bfd_reloc_outofrange:
4762 /* Finish up dynamic symbol handling. We set the contents of various
4763 dynamic sections here. */
4766 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4767 struct elf_link_hash_entry *h,
4768 Elf_Internal_Sym *sym)
4770 struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4771 bfd *dynobj = elf_hash_table(info)->dynobj;
4775 /* Fill in the .plt entry for this symbol. */
4776 asection *splt, *sgot, *srel;
4777 Elf_Internal_Rela outrel;
4779 bfd_vma got_addr, plt_addr;
4781 struct alpha_elf_got_entry *gotent;
4783 BFD_ASSERT (h->dynindx != -1);
4785 splt = bfd_get_section_by_name (dynobj, ".plt");
4786 BFD_ASSERT (splt != NULL);
4787 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4788 BFD_ASSERT (srel != NULL);
4790 for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4791 if (gotent->reloc_type == R_ALPHA_LITERAL
4792 && gotent->use_count > 0)
4797 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4798 BFD_ASSERT (sgot != NULL);
4800 BFD_ASSERT (gotent->got_offset != -1);
4801 BFD_ASSERT (gotent->plt_offset != -1);
4803 got_addr = (sgot->output_section->vma
4804 + sgot->output_offset
4805 + gotent->got_offset);
4806 plt_addr = (splt->output_section->vma
4807 + splt->output_offset
4808 + gotent->plt_offset);
4810 plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4812 /* Fill in the entry in the procedure linkage table. */
4813 if (elf64_alpha_use_secureplt)
4815 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4816 insn = INSN_AD (INSN_BR, 31, disp);
4817 bfd_put_32 (output_bfd, insn,
4818 splt->contents + gotent->plt_offset);
4820 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4821 / NEW_PLT_ENTRY_SIZE);
4825 disp = -(gotent->plt_offset + 4);
4826 insn = INSN_AD (INSN_BR, 28, disp);
4827 bfd_put_32 (output_bfd, insn,
4828 splt->contents + gotent->plt_offset);
4829 bfd_put_32 (output_bfd, INSN_UNOP,
4830 splt->contents + gotent->plt_offset + 4);
4831 bfd_put_32 (output_bfd, INSN_UNOP,
4832 splt->contents + gotent->plt_offset + 8);
4834 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4835 / OLD_PLT_ENTRY_SIZE);
4838 /* Fill in the entry in the .rela.plt section. */
4839 outrel.r_offset = got_addr;
4840 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4841 outrel.r_addend = 0;
4843 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4844 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4846 /* Fill in the entry in the .got. */
4847 bfd_put_64 (output_bfd, plt_addr,
4848 sgot->contents + gotent->got_offset);
4851 else if (alpha_elf_dynamic_symbol_p (h, info))
4853 /* Fill in the dynamic relocations for this symbol's .got entries. */
4855 struct alpha_elf_got_entry *gotent;
4857 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4858 BFD_ASSERT (srel != NULL);
4860 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4862 gotent = gotent->next)
4867 if (gotent->use_count == 0)
4870 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4872 r_type = gotent->reloc_type;
4875 case R_ALPHA_LITERAL:
4876 r_type = R_ALPHA_GLOB_DAT;
4879 r_type = R_ALPHA_DTPMOD64;
4881 case R_ALPHA_GOTDTPREL:
4882 r_type = R_ALPHA_DTPREL64;
4884 case R_ALPHA_GOTTPREL:
4885 r_type = R_ALPHA_TPREL64;
4887 case R_ALPHA_TLSLDM:
4892 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4893 gotent->got_offset, h->dynindx,
4894 r_type, gotent->addend);
4896 if (gotent->reloc_type == R_ALPHA_TLSGD)
4897 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4898 gotent->got_offset + 8, h->dynindx,
4899 R_ALPHA_DTPREL64, gotent->addend);
4903 /* Mark some specially defined symbols as absolute. */
4904 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4905 || h == elf_hash_table (info)->hgot
4906 || h == elf_hash_table (info)->hplt)
4907 sym->st_shndx = SHN_ABS;
4912 /* Finish up the dynamic sections. */
4915 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
4916 struct bfd_link_info *info)
4921 dynobj = elf_hash_table (info)->dynobj;
4922 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4924 if (elf_hash_table (info)->dynamic_sections_created)
4926 asection *splt, *sgotplt, *srelaplt;
4927 Elf64_External_Dyn *dyncon, *dynconend;
4928 bfd_vma plt_vma, gotplt_vma;
4930 splt = bfd_get_section_by_name (dynobj, ".plt");
4931 srelaplt = bfd_get_section_by_name (output_bfd, ".rela.plt");
4932 BFD_ASSERT (splt != NULL && sdyn != NULL);
4934 plt_vma = splt->output_section->vma + splt->output_offset;
4937 if (elf64_alpha_use_secureplt)
4939 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4940 BFD_ASSERT (sgotplt != NULL);
4941 if (sgotplt->size > 0)
4942 gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
4945 dyncon = (Elf64_External_Dyn *) sdyn->contents;
4946 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4947 for (; dyncon < dynconend; dyncon++)
4949 Elf_Internal_Dyn dyn;
4951 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4957 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
4960 dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
4963 dyn.d_un.d_ptr = srelaplt ? srelaplt->vma : 0;
4967 /* My interpretation of the TIS v1.1 ELF document indicates
4968 that RELASZ should not include JMPREL. This is not what
4969 the rest of the BFD does. It is, however, what the
4970 glibc ld.so wants. Do this fixup here until we found
4971 out who is right. */
4973 dyn.d_un.d_val -= srelaplt->size;
4977 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
4980 /* Initialize the plt header. */
4986 if (elf64_alpha_use_secureplt)
4988 ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
4990 insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
4991 bfd_put_32 (output_bfd, insn, splt->contents);
4993 insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
4994 bfd_put_32 (output_bfd, insn, splt->contents + 4);
4996 insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
4997 bfd_put_32 (output_bfd, insn, splt->contents + 8);
4999 insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5000 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5002 insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5003 bfd_put_32 (output_bfd, insn, splt->contents + 16);
5005 insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5006 bfd_put_32 (output_bfd, insn, splt->contents + 20);
5008 insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5009 bfd_put_32 (output_bfd, insn, splt->contents + 24);
5011 insn = INSN_AB (INSN_JMP, 31, 27);
5012 bfd_put_32 (output_bfd, insn, splt->contents + 28);
5014 insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5015 bfd_put_32 (output_bfd, insn, splt->contents + 32);
5019 insn = INSN_AD (INSN_BR, 27, 0); /* br $27, .+4 */
5020 bfd_put_32 (output_bfd, insn, splt->contents);
5022 insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5023 bfd_put_32 (output_bfd, insn, splt->contents + 4);
5026 bfd_put_32 (output_bfd, insn, splt->contents + 8);
5028 insn = INSN_AB (INSN_JMP, 27, 27);
5029 bfd_put_32 (output_bfd, insn, splt->contents + 12);
5031 /* The next two words will be filled in by ld.so. */
5032 bfd_put_64 (output_bfd, 0, splt->contents + 16);
5033 bfd_put_64 (output_bfd, 0, splt->contents + 24);
5036 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5043 /* We need to use a special link routine to handle the .mdebug section.
5044 We need to merge all instances of these sections together, not write
5045 them all out sequentially. */
5048 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5051 struct bfd_link_order *p;
5052 asection *mdebug_sec;
5053 struct ecoff_debug_info debug;
5054 const struct ecoff_debug_swap *swap
5055 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5056 HDRR *symhdr = &debug.symbolic_header;
5057 void * mdebug_handle = NULL;
5058 struct alpha_elf_link_hash_table * htab;
5060 htab = alpha_elf_hash_table (info);
5064 /* Go through the sections and collect the mdebug information. */
5066 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5068 if (strcmp (o->name, ".mdebug") == 0)
5070 struct extsym_info einfo;
5072 /* We have found the .mdebug section in the output file.
5073 Look through all the link_orders comprising it and merge
5074 the information together. */
5075 symhdr->magic = swap->sym_magic;
5076 /* FIXME: What should the version stamp be? */
5078 symhdr->ilineMax = 0;
5082 symhdr->isymMax = 0;
5083 symhdr->ioptMax = 0;
5084 symhdr->iauxMax = 0;
5086 symhdr->issExtMax = 0;
5089 symhdr->iextMax = 0;
5091 /* We accumulate the debugging information itself in the
5092 debug_info structure. */
5094 debug.external_dnr = NULL;
5095 debug.external_pdr = NULL;
5096 debug.external_sym = NULL;
5097 debug.external_opt = NULL;
5098 debug.external_aux = NULL;
5100 debug.ssext = debug.ssext_end = NULL;
5101 debug.external_fdr = NULL;
5102 debug.external_rfd = NULL;
5103 debug.external_ext = debug.external_ext_end = NULL;
5105 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5106 if (mdebug_handle == (PTR) NULL)
5115 static const char * const name[] =
5117 ".text", ".init", ".fini", ".data",
5118 ".rodata", ".sdata", ".sbss", ".bss"
5120 static const int sc[] = { scText, scInit, scFini, scData,
5121 scRData, scSData, scSBss, scBss };
5124 esym.cobol_main = 0;
5128 esym.asym.iss = issNil;
5129 esym.asym.st = stLocal;
5130 esym.asym.reserved = 0;
5131 esym.asym.index = indexNil;
5132 for (i = 0; i < 8; i++)
5134 esym.asym.sc = sc[i];
5135 s = bfd_get_section_by_name (abfd, name[i]);
5138 esym.asym.value = s->vma;
5139 last = s->vma + s->size;
5142 esym.asym.value = last;
5144 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5150 for (p = o->map_head.link_order;
5151 p != (struct bfd_link_order *) NULL;
5154 asection *input_section;
5156 const struct ecoff_debug_swap *input_swap;
5157 struct ecoff_debug_info input_debug;
5161 if (p->type != bfd_indirect_link_order)
5163 if (p->type == bfd_data_link_order)
5168 input_section = p->u.indirect.section;
5169 input_bfd = input_section->owner;
5171 if (! is_alpha_elf (input_bfd))
5172 /* I don't know what a non ALPHA ELF bfd would be
5173 doing with a .mdebug section, but I don't really
5174 want to deal with it. */
5177 input_swap = (get_elf_backend_data (input_bfd)
5178 ->elf_backend_ecoff_debug_swap);
5180 BFD_ASSERT (p->size == input_section->size);
5182 /* The ECOFF linking code expects that we have already
5183 read in the debugging information and set up an
5184 ecoff_debug_info structure, so we do that now. */
5185 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5189 if (! (bfd_ecoff_debug_accumulate
5190 (mdebug_handle, abfd, &debug, swap, input_bfd,
5191 &input_debug, input_swap, info)))
5194 /* Loop through the external symbols. For each one with
5195 interesting information, try to find the symbol in
5196 the linker global hash table and save the information
5197 for the output external symbols. */
5198 eraw_src = (char *) input_debug.external_ext;
5199 eraw_end = (eraw_src
5200 + (input_debug.symbolic_header.iextMax
5201 * input_swap->external_ext_size));
5203 eraw_src < eraw_end;
5204 eraw_src += input_swap->external_ext_size)
5208 struct alpha_elf_link_hash_entry *h;
5210 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
5211 if (ext.asym.sc == scNil
5212 || ext.asym.sc == scUndefined
5213 || ext.asym.sc == scSUndefined)
5216 name = input_debug.ssext + ext.asym.iss;
5217 h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5218 if (h == NULL || h->esym.ifd != -2)
5224 < input_debug.symbolic_header.ifdMax);
5225 ext.ifd = input_debug.ifdmap[ext.ifd];
5231 /* Free up the information we just read. */
5232 free (input_debug.line);
5233 free (input_debug.external_dnr);
5234 free (input_debug.external_pdr);
5235 free (input_debug.external_sym);
5236 free (input_debug.external_opt);
5237 free (input_debug.external_aux);
5238 free (input_debug.ss);
5239 free (input_debug.ssext);
5240 free (input_debug.external_fdr);
5241 free (input_debug.external_rfd);
5242 free (input_debug.external_ext);
5244 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5245 elf_link_input_bfd ignores this section. */
5246 input_section->flags &=~ SEC_HAS_CONTENTS;
5249 /* Build the external symbol information. */
5252 einfo.debug = &debug;
5254 einfo.failed = FALSE;
5255 elf_link_hash_traverse (elf_hash_table (info),
5256 elf64_alpha_output_extsym,
5261 /* Set the size of the .mdebug section. */
5262 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5264 /* Skip this section later on (I don't think this currently
5265 matters, but someday it might). */
5266 o->map_head.link_order = (struct bfd_link_order *) NULL;
5272 /* Invoke the regular ELF backend linker to do all the work. */
5273 if (! bfd_elf_final_link (abfd, info))
5276 /* Now write out the computed sections. */
5278 /* The .got subsections... */
5280 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5281 for (i = htab->got_list;
5283 i = alpha_elf_tdata(i)->got_link_next)
5287 /* elf_bfd_final_link already did everything in dynobj. */
5291 sgot = alpha_elf_tdata(i)->got;
5292 if (! bfd_set_section_contents (abfd, sgot->output_section,
5294 (file_ptr) sgot->output_offset,
5300 if (mdebug_sec != (asection *) NULL)
5302 BFD_ASSERT (abfd->output_has_begun);
5303 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5305 mdebug_sec->filepos))
5308 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5314 static enum elf_reloc_type_class
5315 elf64_alpha_reloc_type_class (const Elf_Internal_Rela *rela)
5317 switch ((int) ELF64_R_TYPE (rela->r_info))
5319 case R_ALPHA_RELATIVE:
5320 return reloc_class_relative;
5321 case R_ALPHA_JMP_SLOT:
5322 return reloc_class_plt;
5324 return reloc_class_copy;
5326 return reloc_class_normal;
5330 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5332 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5333 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5334 { NULL, 0, 0, 0, 0 }
5337 /* ECOFF swapping routines. These are used when dealing with the
5338 .mdebug section, which is in the ECOFF debugging format. Copied
5339 from elf32-mips.c. */
5340 static const struct ecoff_debug_swap
5341 elf64_alpha_ecoff_debug_swap =
5343 /* Symbol table magic number. */
5345 /* Alignment of debugging information. E.g., 4. */
5347 /* Sizes of external symbolic information. */
5348 sizeof (struct hdr_ext),
5349 sizeof (struct dnr_ext),
5350 sizeof (struct pdr_ext),
5351 sizeof (struct sym_ext),
5352 sizeof (struct opt_ext),
5353 sizeof (struct fdr_ext),
5354 sizeof (struct rfd_ext),
5355 sizeof (struct ext_ext),
5356 /* Functions to swap in external symbolic data. */
5365 _bfd_ecoff_swap_tir_in,
5366 _bfd_ecoff_swap_rndx_in,
5367 /* Functions to swap out external symbolic data. */
5376 _bfd_ecoff_swap_tir_out,
5377 _bfd_ecoff_swap_rndx_out,
5378 /* Function to read in symbolic data. */
5379 elf64_alpha_read_ecoff_info
5382 /* Use a non-standard hash bucket size of 8. */
5384 static const struct elf_size_info alpha_elf_size_info =
5386 sizeof (Elf64_External_Ehdr),
5387 sizeof (Elf64_External_Phdr),
5388 sizeof (Elf64_External_Shdr),
5389 sizeof (Elf64_External_Rel),
5390 sizeof (Elf64_External_Rela),
5391 sizeof (Elf64_External_Sym),
5392 sizeof (Elf64_External_Dyn),
5393 sizeof (Elf_External_Note),
5397 ELFCLASS64, EV_CURRENT,
5398 bfd_elf64_write_out_phdrs,
5399 bfd_elf64_write_shdrs_and_ehdr,
5400 bfd_elf64_checksum_contents,
5401 bfd_elf64_write_relocs,
5402 bfd_elf64_swap_symbol_in,
5403 bfd_elf64_swap_symbol_out,
5404 bfd_elf64_slurp_reloc_table,
5405 bfd_elf64_slurp_symbol_table,
5406 bfd_elf64_swap_dyn_in,
5407 bfd_elf64_swap_dyn_out,
5408 bfd_elf64_swap_reloc_in,
5409 bfd_elf64_swap_reloc_out,
5410 bfd_elf64_swap_reloca_in,
5411 bfd_elf64_swap_reloca_out
5414 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5415 #define TARGET_LITTLE_NAME "elf64-alpha"
5416 #define ELF_ARCH bfd_arch_alpha
5417 #define ELF_TARGET_ID ALPHA_ELF_DATA
5418 #define ELF_MACHINE_CODE EM_ALPHA
5419 #define ELF_MAXPAGESIZE 0x10000
5420 #define ELF_COMMONPAGESIZE 0x2000
5422 #define bfd_elf64_bfd_link_hash_table_create \
5423 elf64_alpha_bfd_link_hash_table_create
5425 #define bfd_elf64_bfd_reloc_type_lookup \
5426 elf64_alpha_bfd_reloc_type_lookup
5427 #define bfd_elf64_bfd_reloc_name_lookup \
5428 elf64_alpha_bfd_reloc_name_lookup
5429 #define elf_info_to_howto \
5430 elf64_alpha_info_to_howto
5432 #define bfd_elf64_mkobject \
5433 elf64_alpha_mkobject
5434 #define elf_backend_object_p \
5435 elf64_alpha_object_p
5437 #define elf_backend_section_from_shdr \
5438 elf64_alpha_section_from_shdr
5439 #define elf_backend_section_flags \
5440 elf64_alpha_section_flags
5441 #define elf_backend_fake_sections \
5442 elf64_alpha_fake_sections
5444 #define bfd_elf64_bfd_is_local_label_name \
5445 elf64_alpha_is_local_label_name
5446 #define bfd_elf64_find_nearest_line \
5447 elf64_alpha_find_nearest_line
5448 #define bfd_elf64_bfd_relax_section \
5449 elf64_alpha_relax_section
5451 #define elf_backend_add_symbol_hook \
5452 elf64_alpha_add_symbol_hook
5453 #define elf_backend_relocs_compatible \
5454 _bfd_elf_relocs_compatible
5455 #define elf_backend_check_relocs \
5456 elf64_alpha_check_relocs
5457 #define elf_backend_create_dynamic_sections \
5458 elf64_alpha_create_dynamic_sections
5459 #define elf_backend_adjust_dynamic_symbol \
5460 elf64_alpha_adjust_dynamic_symbol
5461 #define elf_backend_merge_symbol_attribute \
5462 elf64_alpha_merge_symbol_attribute
5463 #define elf_backend_copy_indirect_symbol \
5464 elf64_alpha_copy_indirect_symbol
5465 #define elf_backend_always_size_sections \
5466 elf64_alpha_always_size_sections
5467 #define elf_backend_size_dynamic_sections \
5468 elf64_alpha_size_dynamic_sections
5469 #define elf_backend_omit_section_dynsym \
5470 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5471 #define elf_backend_relocate_section \
5472 elf64_alpha_relocate_section
5473 #define elf_backend_finish_dynamic_symbol \
5474 elf64_alpha_finish_dynamic_symbol
5475 #define elf_backend_finish_dynamic_sections \
5476 elf64_alpha_finish_dynamic_sections
5477 #define bfd_elf64_bfd_final_link \
5478 elf64_alpha_final_link
5479 #define elf_backend_reloc_type_class \
5480 elf64_alpha_reloc_type_class
5482 #define elf_backend_can_gc_sections 1
5483 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5484 #define elf_backend_gc_sweep_hook elf64_alpha_gc_sweep_hook
5486 #define elf_backend_ecoff_debug_swap \
5487 &elf64_alpha_ecoff_debug_swap
5489 #define elf_backend_size_info \
5492 #define elf_backend_special_sections \
5493 elf64_alpha_special_sections
5495 /* A few constants that determine how the .plt section is set up. */
5496 #define elf_backend_want_got_plt 0
5497 #define elf_backend_plt_readonly 0
5498 #define elf_backend_want_plt_sym 1
5499 #define elf_backend_got_header_size 0
5501 #include "elf64-target.h"
5503 /* FreeBSD support. */
5505 #undef TARGET_LITTLE_SYM
5506 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5507 #undef TARGET_LITTLE_NAME
5508 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5510 #define ELF_OSABI ELFOSABI_FREEBSD
5512 /* The kernel recognizes executables as valid only if they carry a
5513 "FreeBSD" label in the ELF header. So we put this label on all
5514 executables and (for simplicity) also all other object files. */
5517 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5518 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5520 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5522 i_ehdrp = elf_elfheader (abfd);
5524 /* Put an ABI label supported by FreeBSD >= 4.1. */
5525 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5526 #ifdef OLD_FREEBSD_ABI_LABEL
5527 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5528 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5532 #undef elf_backend_post_process_headers
5533 #define elf_backend_post_process_headers \
5534 elf64_alpha_fbsd_post_process_headers
5537 #define elf64_bed elf64_alpha_fbsd_bed
5539 #include "elf64-target.h"