1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
52 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
54 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
66 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd *, bfd_reloc_code_real_type));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
77 static boolean elf64_alpha_section_flags
78 PARAMS((flagword *, Elf64_Internal_Shdr *));
79 static boolean elf64_alpha_fake_sections
80 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
81 static boolean elf64_alpha_create_got_section
82 PARAMS((bfd *, struct bfd_link_info *));
83 static boolean elf64_alpha_create_dynamic_sections
84 PARAMS((bfd *, struct bfd_link_info *));
86 static boolean elf64_alpha_read_ecoff_info
87 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
88 static boolean elf64_alpha_is_local_label_name
89 PARAMS((bfd *, const char *));
90 static boolean elf64_alpha_find_nearest_line
91 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
92 const char **, unsigned int *));
94 #if defined(__STDC__) || defined(ALMOST_STDC)
95 struct alpha_elf_link_hash_entry;
98 static boolean elf64_alpha_output_extsym
99 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
101 static boolean elf64_alpha_can_merge_gots
102 PARAMS((bfd *, bfd *));
103 static void elf64_alpha_merge_gots
104 PARAMS((bfd *, bfd *));
105 static boolean elf64_alpha_calc_got_offsets_for_symbol
106 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
107 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
108 static boolean elf64_alpha_size_got_sections
109 PARAMS ((bfd *, struct bfd_link_info *));
110 static boolean elf64_alpha_always_size_sections
111 PARAMS ((bfd *, struct bfd_link_info *));
112 static boolean elf64_alpha_calc_dynrel_sizes
113 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
114 static boolean elf64_alpha_add_symbol_hook
115 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
116 const char **, flagword *, asection **, bfd_vma *));
117 static boolean elf64_alpha_check_relocs
118 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
119 const Elf_Internal_Rela *));
120 static boolean elf64_alpha_adjust_dynamic_symbol
121 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
122 static boolean elf64_alpha_size_dynamic_sections
123 PARAMS((bfd *, struct bfd_link_info *));
124 static boolean elf64_alpha_relocate_section
125 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
126 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
127 static boolean elf64_alpha_finish_dynamic_symbol
128 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
129 Elf_Internal_Sym *));
130 static boolean elf64_alpha_finish_dynamic_sections
131 PARAMS((bfd *, struct bfd_link_info *));
132 static boolean elf64_alpha_final_link
133 PARAMS((bfd *, struct bfd_link_info *));
134 static boolean elf64_alpha_merge_ind_symbols
135 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
136 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
137 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
138 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
139 PARAMS ((const Elf_Internal_Rela *));
141 struct alpha_elf_link_hash_entry
143 struct elf_link_hash_entry root;
145 /* External symbol information. */
148 /* Cumulative flags for all the .got entries. */
151 /* Contexts (LITUSE) in which a literal was referenced. */
152 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
153 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
154 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
155 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
157 /* Used to implement multiple .got subsections. */
158 struct alpha_elf_got_entry
160 struct alpha_elf_got_entry *next;
162 /* which .got subsection? */
165 /* the addend in effect for this entry. */
168 /* the .got offset for this entry. */
173 /* An additional flag. */
174 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
179 /* used to count non-got, non-plt relocations for delayed sizing
180 of relocation sections. */
181 struct alpha_elf_reloc_entry
183 struct alpha_elf_reloc_entry *next;
185 /* which .reloc section? */
188 /* what kind of relocation? */
191 /* is this against read-only section? */
192 unsigned int reltext : 1;
194 /* how many did we find? */
199 /* Alpha ELF linker hash table. */
201 struct alpha_elf_link_hash_table
203 struct elf_link_hash_table root;
205 /* The head of a list of .got subsections linked through
206 alpha_elf_tdata(abfd)->got_link_next. */
210 /* Look up an entry in a Alpha ELF linker hash table. */
212 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
213 ((struct alpha_elf_link_hash_entry *) \
214 elf_link_hash_lookup (&(table)->root, (string), (create), \
217 /* Traverse a Alpha ELF linker hash table. */
219 #define alpha_elf_link_hash_traverse(table, func, info) \
220 (elf_link_hash_traverse \
222 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
225 /* Get the Alpha ELF linker hash table from a link_info structure. */
227 #define alpha_elf_hash_table(p) \
228 ((struct alpha_elf_link_hash_table *) ((p)->hash))
230 /* Get the object's symbols as our own entry type. */
232 #define alpha_elf_sym_hashes(abfd) \
233 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
235 /* Should we do dynamic things to this symbol? */
238 alpha_elf_dynamic_symbol_p (h, info)
239 struct elf_link_hash_entry *h;
240 struct bfd_link_info *info;
245 while (h->root.type == bfd_link_hash_indirect
246 || h->root.type == bfd_link_hash_warning)
247 h = (struct elf_link_hash_entry *) h->root.u.i.link;
249 if (h->dynindx == -1)
252 if (h->root.type == bfd_link_hash_undefweak
253 || h->root.type == bfd_link_hash_defweak)
256 switch (ELF_ST_VISIBILITY (h->other))
264 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
269 if ((info->shared && !info->symbolic)
270 || ((h->elf_link_hash_flags
271 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
272 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
278 /* Create an entry in a Alpha ELF linker hash table. */
280 static struct bfd_hash_entry *
281 elf64_alpha_link_hash_newfunc (entry, table, string)
282 struct bfd_hash_entry *entry;
283 struct bfd_hash_table *table;
286 struct alpha_elf_link_hash_entry *ret =
287 (struct alpha_elf_link_hash_entry *) entry;
289 /* Allocate the structure if it has not already been allocated by a
291 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
292 ret = ((struct alpha_elf_link_hash_entry *)
293 bfd_hash_allocate (table,
294 sizeof (struct alpha_elf_link_hash_entry)));
295 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
296 return (struct bfd_hash_entry *) ret;
298 /* Call the allocation method of the superclass. */
299 ret = ((struct alpha_elf_link_hash_entry *)
300 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
302 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
304 /* Set local fields. */
305 memset (&ret->esym, 0, sizeof (EXTR));
306 /* We use -2 as a marker to indicate that the information has
307 not been set. -1 means there is no associated ifd. */
310 ret->got_entries = NULL;
311 ret->reloc_entries = NULL;
314 return (struct bfd_hash_entry *) ret;
317 /* Create a Alpha ELF linker hash table. */
319 static struct bfd_link_hash_table *
320 elf64_alpha_bfd_link_hash_table_create (abfd)
323 struct alpha_elf_link_hash_table *ret;
324 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
326 ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
327 if (ret == (struct alpha_elf_link_hash_table *) NULL)
330 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
331 elf64_alpha_link_hash_newfunc))
333 bfd_release (abfd, ret);
337 return &ret->root.root;
340 /* We have some private fields hanging off of the elf_tdata structure. */
342 struct alpha_elf_obj_tdata
344 struct elf_obj_tdata root;
346 /* For every input file, these are the got entries for that object's
348 struct alpha_elf_got_entry ** local_got_entries;
350 /* For every input file, this is the object that owns the got that
351 this input file uses. */
354 /* For every got, this is a linked list through the objects using this got */
355 bfd *in_got_link_next;
357 /* For every got, this is a link to the next got subsegment. */
360 /* For every got, this is the section. */
363 /* For every got, this is it's total number of *entries*. */
364 int total_got_entries;
366 /* For every got, this is the sum of the number of *entries* required
367 to hold all of the member object's local got. */
368 int n_local_got_entries;
371 #define alpha_elf_tdata(abfd) \
372 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
375 elf64_alpha_mkobject (abfd)
378 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
379 abfd->tdata.any = bfd_zalloc (abfd, amt);
380 if (abfd->tdata.any == NULL)
386 elf64_alpha_object_p (abfd)
389 /* Allocate our special target data. */
390 struct alpha_elf_obj_tdata *new_tdata;
391 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
392 new_tdata = bfd_zalloc (abfd, amt);
393 if (new_tdata == NULL)
395 new_tdata->root = *abfd->tdata.elf_obj_data;
396 abfd->tdata.any = new_tdata;
398 /* Set the right machine number for an Alpha ELF file. */
399 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
402 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
403 from smaller values. Start with zero, widen, *then* decrement. */
404 #define MINUS_ONE (((bfd_vma)0) - 1)
406 #define SKIP_HOWTO(N) \
407 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
409 static reloc_howto_type elf64_alpha_howto_table[] =
411 HOWTO (R_ALPHA_NONE, /* type */
413 0, /* size (0 = byte, 1 = short, 2 = long) */
415 true, /* pc_relative */
417 complain_overflow_dont, /* complain_on_overflow */
418 elf64_alpha_reloc_nil, /* special_function */
420 false, /* partial_inplace */
423 true), /* pcrel_offset */
425 /* A 32 bit reference to a symbol. */
426 HOWTO (R_ALPHA_REFLONG, /* type */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
430 false, /* pc_relative */
432 complain_overflow_bitfield, /* complain_on_overflow */
433 0, /* special_function */
434 "REFLONG", /* name */
435 false, /* partial_inplace */
436 0xffffffff, /* src_mask */
437 0xffffffff, /* dst_mask */
438 false), /* pcrel_offset */
440 /* A 64 bit reference to a symbol. */
441 HOWTO (R_ALPHA_REFQUAD, /* type */
443 4, /* size (0 = byte, 1 = short, 2 = long) */
445 false, /* pc_relative */
447 complain_overflow_bitfield, /* complain_on_overflow */
448 0, /* special_function */
449 "REFQUAD", /* name */
450 false, /* partial_inplace */
451 MINUS_ONE, /* src_mask */
452 MINUS_ONE, /* dst_mask */
453 false), /* pcrel_offset */
455 /* A 32 bit GP relative offset. This is just like REFLONG except
456 that when the value is used the value of the gp register will be
458 HOWTO (R_ALPHA_GPREL32, /* type */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
462 false, /* pc_relative */
464 complain_overflow_bitfield, /* complain_on_overflow */
465 0, /* special_function */
466 "GPREL32", /* name */
467 false, /* partial_inplace */
468 0xffffffff, /* src_mask */
469 0xffffffff, /* dst_mask */
470 false), /* pcrel_offset */
472 /* Used for an instruction that refers to memory off the GP register. */
473 HOWTO (R_ALPHA_LITERAL, /* type */
475 1, /* size (0 = byte, 1 = short, 2 = long) */
477 false, /* pc_relative */
479 complain_overflow_signed, /* complain_on_overflow */
480 0, /* special_function */
481 "ELF_LITERAL", /* name */
482 false, /* partial_inplace */
483 0xffff, /* src_mask */
484 0xffff, /* dst_mask */
485 false), /* pcrel_offset */
487 /* This reloc only appears immediately following an ELF_LITERAL reloc.
488 It identifies a use of the literal. The symbol index is special:
489 1 means the literal address is in the base register of a memory
490 format instruction; 2 means the literal address is in the byte
491 offset register of a byte-manipulation instruction; 3 means the
492 literal address is in the target register of a jsr instruction.
493 This does not actually do any relocation. */
494 HOWTO (R_ALPHA_LITUSE, /* type */
496 1, /* size (0 = byte, 1 = short, 2 = long) */
498 false, /* pc_relative */
500 complain_overflow_dont, /* complain_on_overflow */
501 elf64_alpha_reloc_nil, /* special_function */
503 false, /* partial_inplace */
506 false), /* pcrel_offset */
508 /* Load the gp register. This is always used for a ldah instruction
509 which loads the upper 16 bits of the gp register. The symbol
510 index of the GPDISP instruction is an offset in bytes to the lda
511 instruction that loads the lower 16 bits. The value to use for
512 the relocation is the difference between the GP value and the
513 current location; the load will always be done against a register
514 holding the current address.
516 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
517 any offset is present in the instructions, it is an offset from
518 the register to the ldah instruction. This lets us avoid any
519 stupid hackery like inventing a gp value to do partial relocation
520 against. Also unlike ECOFF, we do the whole relocation off of
521 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
522 space consuming bit, that, since all the information was present
523 in the GPDISP_HI16 reloc. */
524 HOWTO (R_ALPHA_GPDISP, /* type */
526 2, /* size (0 = byte, 1 = short, 2 = long) */
528 false, /* pc_relative */
530 complain_overflow_dont, /* complain_on_overflow */
531 elf64_alpha_reloc_gpdisp, /* special_function */
533 false, /* partial_inplace */
534 0xffff, /* src_mask */
535 0xffff, /* dst_mask */
536 true), /* pcrel_offset */
538 /* A 21 bit branch. */
539 HOWTO (R_ALPHA_BRADDR, /* type */
541 2, /* size (0 = byte, 1 = short, 2 = long) */
543 true, /* pc_relative */
545 complain_overflow_signed, /* complain_on_overflow */
546 0, /* special_function */
548 false, /* partial_inplace */
549 0x1fffff, /* src_mask */
550 0x1fffff, /* dst_mask */
551 true), /* pcrel_offset */
553 /* A hint for a jump to a register. */
554 HOWTO (R_ALPHA_HINT, /* type */
556 1, /* size (0 = byte, 1 = short, 2 = long) */
558 true, /* pc_relative */
560 complain_overflow_dont, /* complain_on_overflow */
561 0, /* special_function */
563 false, /* partial_inplace */
564 0x3fff, /* src_mask */
565 0x3fff, /* dst_mask */
566 true), /* pcrel_offset */
568 /* 16 bit PC relative offset. */
569 HOWTO (R_ALPHA_SREL16, /* type */
571 1, /* size (0 = byte, 1 = short, 2 = long) */
573 true, /* pc_relative */
575 complain_overflow_signed, /* complain_on_overflow */
576 0, /* special_function */
578 false, /* partial_inplace */
579 0xffff, /* src_mask */
580 0xffff, /* dst_mask */
581 true), /* pcrel_offset */
583 /* 32 bit PC relative offset. */
584 HOWTO (R_ALPHA_SREL32, /* type */
586 2, /* size (0 = byte, 1 = short, 2 = long) */
588 true, /* pc_relative */
590 complain_overflow_signed, /* complain_on_overflow */
591 0, /* special_function */
593 false, /* partial_inplace */
594 0xffffffff, /* src_mask */
595 0xffffffff, /* dst_mask */
596 true), /* pcrel_offset */
598 /* A 64 bit PC relative offset. */
599 HOWTO (R_ALPHA_SREL64, /* type */
601 4, /* size (0 = byte, 1 = short, 2 = long) */
603 true, /* pc_relative */
605 complain_overflow_signed, /* complain_on_overflow */
606 0, /* special_function */
608 false, /* partial_inplace */
609 MINUS_ONE, /* src_mask */
610 MINUS_ONE, /* dst_mask */
611 true), /* pcrel_offset */
613 /* Skip 12 - 16; deprecated ECOFF relocs. */
620 /* The high 16 bits of the displacement from GP to the target. */
621 HOWTO (R_ALPHA_GPRELHIGH,
623 1, /* size (0 = byte, 1 = short, 2 = long) */
625 false, /* pc_relative */
627 complain_overflow_signed, /* complain_on_overflow */
628 0, /* special_function */
629 "GPRELHIGH", /* name */
630 false, /* partial_inplace */
631 0xffff, /* src_mask */
632 0xffff, /* dst_mask */
633 false), /* pcrel_offset */
635 /* The low 16 bits of the displacement from GP to the target. */
636 HOWTO (R_ALPHA_GPRELLOW,
638 1, /* size (0 = byte, 1 = short, 2 = long) */
640 false, /* pc_relative */
642 complain_overflow_dont, /* complain_on_overflow */
643 0, /* special_function */
644 "GPRELLOW", /* name */
645 false, /* partial_inplace */
646 0xffff, /* src_mask */
647 0xffff, /* dst_mask */
648 false), /* pcrel_offset */
650 /* A 16-bit displacement from the GP to the target. */
651 HOWTO (R_ALPHA_GPREL16,
653 1, /* size (0 = byte, 1 = short, 2 = long) */
655 false, /* pc_relative */
657 complain_overflow_signed, /* complain_on_overflow */
658 0, /* special_function */
659 "GPREL16", /* name */
660 false, /* partial_inplace */
661 0xffff, /* src_mask */
662 0xffff, /* dst_mask */
663 false), /* pcrel_offset */
665 /* Skip 20 - 23; deprecated ECOFF relocs. */
671 /* Misc ELF relocations. */
673 /* A dynamic relocation to copy the target into our .dynbss section. */
674 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
675 is present because every other ELF has one, but should not be used
676 because .dynbss is an ugly thing. */
683 complain_overflow_dont,
684 bfd_elf_generic_reloc,
691 /* A dynamic relocation for a .got entry. */
692 HOWTO (R_ALPHA_GLOB_DAT,
698 complain_overflow_dont,
699 bfd_elf_generic_reloc,
706 /* A dynamic relocation for a .plt entry. */
707 HOWTO (R_ALPHA_JMP_SLOT,
713 complain_overflow_dont,
714 bfd_elf_generic_reloc,
721 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
722 HOWTO (R_ALPHA_RELATIVE,
728 complain_overflow_dont,
729 bfd_elf_generic_reloc,
737 /* A relocation function which doesn't do anything. */
739 static bfd_reloc_status_type
740 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
741 bfd *abfd ATTRIBUTE_UNUSED;
743 asymbol *sym ATTRIBUTE_UNUSED;
744 PTR data ATTRIBUTE_UNUSED;
747 char **error_message ATTRIBUTE_UNUSED;
750 reloc->address += sec->output_offset;
754 /* A relocation function used for an unsupported reloc. */
756 static bfd_reloc_status_type
757 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
758 bfd *abfd ATTRIBUTE_UNUSED;
760 asymbol *sym ATTRIBUTE_UNUSED;
761 PTR data ATTRIBUTE_UNUSED;
764 char **error_message ATTRIBUTE_UNUSED;
767 reloc->address += sec->output_offset;
768 return bfd_reloc_notsupported;
771 /* Do the work of the GPDISP relocation. */
773 static bfd_reloc_status_type
774 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
780 bfd_reloc_status_type ret = bfd_reloc_ok;
782 unsigned long i_ldah, i_lda;
784 i_ldah = bfd_get_32 (abfd, p_ldah);
785 i_lda = bfd_get_32 (abfd, p_lda);
787 /* Complain if the instructions are not correct. */
788 if (((i_ldah >> 26) & 0x3f) != 0x09
789 || ((i_lda >> 26) & 0x3f) != 0x08)
790 ret = bfd_reloc_dangerous;
792 /* Extract the user-supplied offset, mirroring the sign extensions
793 that the instructions perform. */
794 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
795 addend = (addend ^ 0x80008000) - 0x80008000;
799 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
800 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
801 ret = bfd_reloc_overflow;
803 /* compensate for the sign extension again. */
804 i_ldah = ((i_ldah & 0xffff0000)
805 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
806 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
808 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
809 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
814 /* The special function for the GPDISP reloc. */
816 static bfd_reloc_status_type
817 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
820 arelent *reloc_entry;
821 asymbol *sym ATTRIBUTE_UNUSED;
823 asection *input_section;
827 bfd_reloc_status_type ret;
828 bfd_vma gp, relocation;
829 bfd_byte *p_ldah, *p_lda;
831 /* Don't do anything if we're not doing a final link. */
834 reloc_entry->address += input_section->output_offset;
838 if (reloc_entry->address > input_section->_cooked_size ||
839 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
840 return bfd_reloc_outofrange;
842 /* The gp used in the portion of the output object to which this
843 input object belongs is cached on the input bfd. */
844 gp = _bfd_get_gp_value (abfd);
846 relocation = (input_section->output_section->vma
847 + input_section->output_offset
848 + reloc_entry->address);
850 p_ldah = (bfd_byte *) data + reloc_entry->address;
851 p_lda = p_ldah + reloc_entry->addend;
853 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
855 /* Complain if the instructions are not correct. */
856 if (ret == bfd_reloc_dangerous)
857 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
862 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
866 bfd_reloc_code_real_type bfd_reloc_val;
870 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
872 {BFD_RELOC_NONE, R_ALPHA_NONE},
873 {BFD_RELOC_32, R_ALPHA_REFLONG},
874 {BFD_RELOC_64, R_ALPHA_REFQUAD},
875 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
876 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
877 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
878 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
879 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
880 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
881 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
882 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
883 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
884 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
885 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
886 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
887 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
890 /* Given a BFD reloc type, return a HOWTO structure. */
892 static reloc_howto_type *
893 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
894 bfd *abfd ATTRIBUTE_UNUSED;
895 bfd_reloc_code_real_type code;
897 const struct elf_reloc_map *i, *e;
898 i = e = elf64_alpha_reloc_map;
899 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
902 if (i->bfd_reloc_val == code)
903 return &elf64_alpha_howto_table[i->elf_reloc_val];
908 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
911 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
912 bfd *abfd ATTRIBUTE_UNUSED;
914 Elf64_Internal_Rela *dst;
918 r_type = ELF64_R_TYPE(dst->r_info);
919 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
920 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
923 /* These functions do relaxation for Alpha ELF.
925 Currently I'm only handling what I can do with existing compiler
926 and assembler support, which means no instructions are removed,
927 though some may be nopped. At this time GCC does not emit enough
928 information to do all of the relaxing that is possible. It will
929 take some not small amount of work for that to happen.
931 There are a couple of interesting papers that I once read on this
932 subject, that I cannot find references to at the moment, that
933 related to Alpha in particular. They are by David Wall, then of
938 #define INSN_JSR 0x68004000
939 #define INSN_JSR_MASK 0xfc00c000
943 #define INSN_UNOP 0x2fe00000
945 struct alpha_relax_info
950 Elf_Internal_Rela *relocs, *relend;
951 struct bfd_link_info *link_info;
952 boolean changed_contents;
953 boolean changed_relocs;
957 struct alpha_elf_link_hash_entry *h;
958 struct alpha_elf_got_entry *gotent;
962 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
963 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
964 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
966 static boolean elf64_alpha_relax_without_lituse
967 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
968 Elf_Internal_Rela *irel));
970 static bfd_vma elf64_alpha_relax_opt_call
971 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
973 static boolean elf64_alpha_relax_section
974 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
977 static Elf_Internal_Rela *
978 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
979 Elf_Internal_Rela *rel, *relend;
985 if (rel->r_offset == offset
986 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
993 static Elf_Internal_Rela *
994 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
995 struct alpha_relax_info *info;
997 Elf_Internal_Rela *irel, *irelend;
999 Elf_Internal_Rela *urel;
1000 int flags, count, i;
1001 bfd_signed_vma disp;
1004 boolean lit_reused = false;
1005 boolean all_optimized = true;
1006 unsigned int lit_insn;
1008 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1009 if (lit_insn >> 26 != OP_LDQ)
1011 ((*_bfd_error_handler)
1012 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1013 bfd_archive_filename (info->abfd), info->sec->name,
1014 (unsigned long) irel->r_offset));
1018 /* Summarize how this particular LITERAL is used. */
1019 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1021 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1023 if (urel->r_addend <= 3)
1024 flags |= 1 << urel->r_addend;
1027 /* A little preparation for the loop... */
1028 disp = symval - info->gp;
1030 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1034 bfd_signed_vma xdisp;
1036 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1038 switch (urel->r_addend)
1040 default: /* 0 = ADDRESS FORMAT */
1041 /* This type is really just a placeholder to note that all
1042 uses cannot be optimized, but to still allow some. */
1043 all_optimized = false;
1046 case 1: /* MEM FORMAT */
1047 /* We can always optimize 16-bit displacements. */
1049 /* Extract the displacement from the instruction, sign-extending
1050 it if necessary, then test whether it is within 16 or 32 bits
1051 displacement from GP. */
1052 insn_disp = insn & 0x0000ffff;
1053 if (insn_disp & 0x00008000)
1054 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1056 xdisp = disp + insn_disp;
1057 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1058 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1062 /* Take the op code and dest from this insn, take the base
1063 register from the literal insn. Leave the offset alone. */
1064 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1065 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1067 urel->r_addend = irel->r_addend;
1068 info->changed_relocs = true;
1070 bfd_put_32 (info->abfd, (bfd_vma) insn,
1071 info->contents + urel->r_offset);
1072 info->changed_contents = true;
1075 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1076 else if (fits32 && !(flags & ~6))
1078 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1080 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1082 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1083 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1084 info->contents + irel->r_offset);
1086 info->changed_contents = true;
1088 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1090 urel->r_addend = irel->r_addend;
1091 info->changed_relocs = true;
1094 all_optimized = false;
1097 case 2: /* BYTE OFFSET FORMAT */
1098 /* We can always optimize byte instructions. */
1100 /* FIXME: sanity check the insn for byte op. Check that the
1101 literal dest reg is indeed Rb in the byte insn. */
1103 insn &= ~ (unsigned) 0x001ff000;
1104 insn |= ((symval & 7) << 13) | 0x1000;
1106 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1108 info->changed_relocs = true;
1110 bfd_put_32 (info->abfd, (bfd_vma) insn,
1111 info->contents + urel->r_offset);
1112 info->changed_contents = true;
1115 case 3: /* CALL FORMAT */
1117 /* If not zero, place to jump without needing pv. */
1118 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1119 bfd_vma org = (info->sec->output_section->vma
1120 + info->sec->output_offset
1121 + urel->r_offset + 4);
1122 bfd_signed_vma odisp;
1124 odisp = (optdest ? optdest : symval) - org;
1125 if (odisp >= -0x400000 && odisp < 0x400000)
1127 Elf_Internal_Rela *xrel;
1129 /* Preserve branch prediction call stack when possible. */
1130 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1131 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1133 insn = (OP_BR << 26) | (insn & 0x03e00000);
1135 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1137 urel->r_addend = irel->r_addend;
1140 urel->r_addend += optdest - symval;
1142 all_optimized = false;
1144 bfd_put_32 (info->abfd, (bfd_vma) insn,
1145 info->contents + urel->r_offset);
1147 /* Kill any HINT reloc that might exist for this insn. */
1148 xrel = (elf64_alpha_find_reloc_at_ofs
1149 (info->relocs, info->relend, urel->r_offset,
1152 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1154 info->changed_contents = true;
1155 info->changed_relocs = true;
1158 all_optimized = false;
1160 /* Even if the target is not in range for a direct branch,
1161 if we share a GP, we can eliminate the gp reload. */
1164 Elf_Internal_Rela *gpdisp
1165 = (elf64_alpha_find_reloc_at_ofs
1166 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1169 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1170 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1171 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1172 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1174 /* Verify that the instruction is "ldah $29,0($26)".
1175 Consider a function that ends in a noreturn call,
1176 and that the next function begins with an ldgp,
1177 and that by accident there is no padding between.
1178 In that case the insn would use $27 as the base. */
1179 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1181 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1182 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1184 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1185 info->changed_contents = true;
1186 info->changed_relocs = true;
1195 /* If all cases were optimized, we can reduce the use count on this
1196 got entry by one, possibly eliminating it. */
1199 info->gotent->use_count -= 1;
1200 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1202 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1204 /* If the literal instruction is no longer needed (it may have been
1205 reused. We can eliminate it.
1206 ??? For now, I don't want to deal with compacting the section,
1207 so just nop it out. */
1210 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1211 info->changed_relocs = true;
1213 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1214 info->contents + irel->r_offset);
1215 info->changed_contents = true;
1219 return irel + count;
1223 elf64_alpha_relax_opt_call (info, symval)
1224 struct alpha_relax_info *info;
1227 /* If the function has the same gp, and we can identify that the
1228 function does not use its function pointer, we can eliminate the
1231 /* If the symbol is marked NOPV, we are being told the function never
1232 needs its procedure value. */
1233 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1236 /* If the symbol is marked STD_GP, we are being told the function does
1237 a normal ldgp in the first two words. */
1238 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1241 /* Otherwise, we may be able to identify a GP load in the first two
1242 words, which we can then skip. */
1245 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1248 /* Load the relocations from the section that the target symbol is in. */
1249 if (info->sec == info->tsec)
1251 tsec_relocs = info->relocs;
1252 tsec_relend = info->relend;
1257 tsec_relocs = (_bfd_elf64_link_read_relocs
1258 (info->abfd, info->tsec, (PTR) NULL,
1259 (Elf_Internal_Rela *) NULL,
1260 info->link_info->keep_memory));
1261 if (tsec_relocs == NULL)
1263 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1264 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1267 /* Recover the symbol's offset within the section. */
1268 ofs = (symval - info->tsec->output_section->vma
1269 - info->tsec->output_offset);
1271 /* Look for a GPDISP reloc. */
1272 gpdisp = (elf64_alpha_find_reloc_at_ofs
1273 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1275 if (!gpdisp || gpdisp->r_addend != 4)
1285 /* We've now determined that we can skip an initial gp load. Verify
1286 that the call and the target use the same gp. */
1287 if (info->link_info->hash->creator != info->tsec->owner->xvec
1288 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1295 elf64_alpha_relax_without_lituse (info, symval, irel)
1296 struct alpha_relax_info *info;
1298 Elf_Internal_Rela *irel;
1301 bfd_signed_vma disp;
1303 /* Get the instruction. */
1304 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1306 if (insn >> 26 != OP_LDQ)
1308 ((*_bfd_error_handler)
1309 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1310 bfd_archive_filename (info->abfd), info->sec->name,
1311 (unsigned long) irel->r_offset));
1315 /* So we aren't told much. Do what we can with the address load and
1316 fake the rest. All of the optimizations here require that the
1317 offset from the GP fit in 16 bits. */
1319 disp = symval - info->gp;
1320 if (disp < -0x8000 || disp >= 0x8000)
1323 /* On the LITERAL instruction itself, consider exchanging
1324 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1326 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1327 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1328 info->changed_contents = true;
1330 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1331 info->changed_relocs = true;
1333 /* Reduce the use count on this got entry by one, possibly
1335 info->gotent->use_count -= 1;
1336 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1338 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1340 /* ??? Search forward through this basic block looking for insns
1341 that use the target register. Stop after an insn modifying the
1342 register is seen, or after a branch or call.
1344 Any such memory load insn may be substituted by a load directly
1345 off the GP. This allows the memory load insn to be issued before
1346 the calculated GP register would otherwise be ready.
1348 Any such jsr insn can be replaced by a bsr if it is in range.
1350 This would mean that we'd have to _add_ relocations, the pain of
1351 which gives one pause. */
1357 elf64_alpha_relax_section (abfd, sec, link_info, again)
1360 struct bfd_link_info *link_info;
1363 Elf_Internal_Shdr *symtab_hdr;
1364 Elf_Internal_Rela *internal_relocs;
1365 Elf_Internal_Rela *free_relocs = NULL;
1366 Elf_Internal_Rela *irel, *irelend;
1367 bfd_byte *free_contents = NULL;
1368 Elf64_External_Sym *extsyms = NULL;
1369 Elf64_External_Sym *free_extsyms = NULL;
1370 struct alpha_elf_got_entry **local_got_entries;
1371 struct alpha_relax_info info;
1373 /* We are not currently changing any sizes, so only one pass. */
1376 if (link_info->relocateable
1377 || (sec->flags & SEC_RELOC) == 0
1378 || sec->reloc_count == 0)
1381 /* If this is the first time we have been called for this section,
1382 initialize the cooked size. */
1383 if (sec->_cooked_size == 0)
1384 sec->_cooked_size = sec->_raw_size;
1386 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1387 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1389 /* Load the relocations for this section. */
1390 internal_relocs = (_bfd_elf64_link_read_relocs
1391 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1392 link_info->keep_memory));
1393 if (internal_relocs == NULL)
1395 if (! link_info->keep_memory)
1396 free_relocs = internal_relocs;
1398 memset(&info, 0, sizeof (info));
1401 info.link_info = link_info;
1402 info.relocs = internal_relocs;
1403 info.relend = irelend = internal_relocs + sec->reloc_count;
1405 /* Find the GP for this object. */
1406 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1409 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1410 info.gp = _bfd_get_gp_value (info.gotobj);
1413 info.gp = (sgot->output_section->vma
1414 + sgot->output_offset
1416 _bfd_set_gp_value (info.gotobj, info.gp);
1420 for (irel = internal_relocs; irel < irelend; irel++)
1423 Elf_Internal_Sym isym;
1424 struct alpha_elf_got_entry *gotent;
1426 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1429 /* Get the section contents. */
1430 if (info.contents == NULL)
1432 if (elf_section_data (sec)->this_hdr.contents != NULL)
1433 info.contents = elf_section_data (sec)->this_hdr.contents;
1436 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1437 if (info.contents == NULL)
1439 free_contents = info.contents;
1441 if (! bfd_get_section_contents (abfd, sec, info.contents,
1442 (file_ptr) 0, sec->_raw_size))
1447 /* Read this BFD's symbols if we haven't done so already. */
1448 if (extsyms == NULL)
1450 if (symtab_hdr->contents != NULL)
1451 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1454 extsyms = (Elf64_External_Sym *) bfd_malloc (symtab_hdr->sh_size);
1455 if (extsyms == NULL)
1457 free_extsyms = extsyms;
1458 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1459 || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
1460 != symtab_hdr->sh_size))
1465 /* Get the value of the symbol referred to by the reloc. */
1466 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1468 /* A local symbol. */
1469 bfd_elf64_swap_symbol_in (abfd,
1470 extsyms + ELF64_R_SYM (irel->r_info),
1472 if (isym.st_shndx == SHN_UNDEF)
1473 info.tsec = bfd_und_section_ptr;
1474 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1475 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1476 else if (isym.st_shndx == SHN_ABS)
1477 info.tsec = bfd_abs_section_ptr;
1478 else if (isym.st_shndx == SHN_COMMON)
1479 info.tsec = bfd_com_section_ptr;
1481 continue; /* who knows. */
1484 info.other = isym.st_other;
1485 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1486 symval = isym.st_value;
1491 struct alpha_elf_link_hash_entry *h;
1493 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1494 h = alpha_elf_sym_hashes (abfd)[indx];
1495 BFD_ASSERT (h != NULL);
1497 while (h->root.root.type == bfd_link_hash_indirect
1498 || h->root.root.type == bfd_link_hash_warning)
1499 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1501 /* We can't do anthing with undefined or dynamic symbols. */
1502 if (h->root.root.type == bfd_link_hash_undefined
1503 || h->root.root.type == bfd_link_hash_undefweak
1504 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1508 info.tsec = h->root.root.u.def.section;
1509 info.other = h->root.other;
1510 gotent = h->got_entries;
1511 symval = h->root.root.u.def.value;
1514 /* Search for the got entry to be used by this relocation. */
1515 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1516 gotent = gotent->next;
1517 info.gotent = gotent;
1519 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1520 symval += irel->r_addend;
1522 BFD_ASSERT(info.gotent != NULL);
1524 /* If there exist LITUSE relocations immediately following, this
1525 opens up all sorts of interesting optimizations, because we
1526 now know every location that this address load is used. */
1528 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1530 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1536 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1541 if (!elf64_alpha_size_got_sections (abfd, link_info))
1544 if (info.changed_relocs)
1546 elf_section_data (sec)->relocs = internal_relocs;
1548 else if (free_relocs != NULL)
1553 if (info.changed_contents)
1555 elf_section_data (sec)->this_hdr.contents = info.contents;
1557 else if (free_contents != NULL)
1559 if (! link_info->keep_memory)
1560 free (free_contents);
1563 /* Cache the section contents for elf_link_input_bfd. */
1564 elf_section_data (sec)->this_hdr.contents = info.contents;
1568 if (free_extsyms != NULL)
1570 if (! link_info->keep_memory)
1571 free (free_extsyms);
1574 /* Cache the symbols for elf_link_input_bfd. */
1575 symtab_hdr->contents = (unsigned char *) extsyms;
1579 *again = info.changed_contents || info.changed_relocs;
1584 if (free_relocs != NULL)
1586 if (free_contents != NULL)
1587 free (free_contents);
1588 if (free_extsyms != NULL)
1589 free (free_extsyms);
1594 #define PLT_HEADER_SIZE 32
1595 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1596 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1597 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1598 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
1600 #define PLT_ENTRY_SIZE 12
1601 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1602 #define PLT_ENTRY_WORD2 0
1603 #define PLT_ENTRY_WORD3 0
1605 #define MAX_GOT_ENTRIES (64*1024 / 8)
1607 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1609 /* Handle an Alpha specific section when reading an object file. This
1610 is called when elfcode.h finds a section with an unknown type.
1611 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1615 elf64_alpha_section_from_shdr (abfd, hdr, name)
1617 Elf64_Internal_Shdr *hdr;
1622 /* There ought to be a place to keep ELF backend specific flags, but
1623 at the moment there isn't one. We just keep track of the
1624 sections by their name, instead. Fortunately, the ABI gives
1625 suggested names for all the MIPS specific sections, so we will
1626 probably get away with this. */
1627 switch (hdr->sh_type)
1629 case SHT_ALPHA_DEBUG:
1630 if (strcmp (name, ".mdebug") != 0)
1637 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1639 newsect = hdr->bfd_section;
1641 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1643 if (! bfd_set_section_flags (abfd, newsect,
1644 (bfd_get_section_flags (abfd, newsect)
1652 /* Convert Alpha specific section flags to bfd internal section flags. */
1655 elf64_alpha_section_flags (flags, hdr)
1657 Elf64_Internal_Shdr *hdr;
1659 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1660 *flags |= SEC_SMALL_DATA;
1665 /* Set the correct type for an Alpha ELF section. We do this by the
1666 section name, which is a hack, but ought to work. */
1669 elf64_alpha_fake_sections (abfd, hdr, sec)
1671 Elf64_Internal_Shdr *hdr;
1674 register const char *name;
1676 name = bfd_get_section_name (abfd, sec);
1678 if (strcmp (name, ".mdebug") == 0)
1680 hdr->sh_type = SHT_ALPHA_DEBUG;
1681 /* In a shared object on Irix 5.3, the .mdebug section has an
1682 entsize of 0. FIXME: Does this matter? */
1683 if ((abfd->flags & DYNAMIC) != 0 )
1684 hdr->sh_entsize = 0;
1686 hdr->sh_entsize = 1;
1688 else if ((sec->flags & SEC_SMALL_DATA)
1689 || strcmp (name, ".sdata") == 0
1690 || strcmp (name, ".sbss") == 0
1691 || strcmp (name, ".lit4") == 0
1692 || strcmp (name, ".lit8") == 0)
1693 hdr->sh_flags |= SHF_ALPHA_GPREL;
1698 /* Hook called by the linker routine which adds symbols from an object
1699 file. We use it to put .comm items in .sbss, and not .bss. */
1702 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1704 struct bfd_link_info *info;
1705 const Elf_Internal_Sym *sym;
1706 const char **namep ATTRIBUTE_UNUSED;
1707 flagword *flagsp ATTRIBUTE_UNUSED;
1711 if (sym->st_shndx == SHN_COMMON
1712 && !info->relocateable
1713 && sym->st_size <= elf_gp_size (abfd))
1715 /* Common symbols less than or equal to -G nn bytes are
1716 automatically put into .sbss. */
1718 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1722 scomm = bfd_make_section (abfd, ".scommon");
1724 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1726 | SEC_LINKER_CREATED)))
1731 *valp = sym->st_size;
1737 /* Create the .got section. */
1740 elf64_alpha_create_got_section(abfd, info)
1742 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1746 if (bfd_get_section_by_name (abfd, ".got"))
1749 s = bfd_make_section (abfd, ".got");
1751 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1754 | SEC_LINKER_CREATED))
1755 || !bfd_set_section_alignment (abfd, s, 3))
1758 alpha_elf_tdata (abfd)->got = s;
1763 /* Create all the dynamic sections. */
1766 elf64_alpha_create_dynamic_sections (abfd, info)
1768 struct bfd_link_info *info;
1771 struct elf_link_hash_entry *h;
1773 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1775 s = bfd_make_section (abfd, ".plt");
1777 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1780 | SEC_LINKER_CREATED
1782 || ! bfd_set_section_alignment (abfd, s, 3))
1785 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1788 if (! (_bfd_generic_link_add_one_symbol
1789 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1790 (bfd_vma) 0, (const char *) NULL, false,
1791 get_elf_backend_data (abfd)->collect,
1792 (struct bfd_link_hash_entry **) &h)))
1794 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1795 h->type = STT_OBJECT;
1798 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1801 s = bfd_make_section (abfd, ".rela.plt");
1803 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1806 | SEC_LINKER_CREATED
1808 || ! bfd_set_section_alignment (abfd, s, 3))
1811 /* We may or may not have created a .got section for this object, but
1812 we definitely havn't done the rest of the work. */
1814 if (!elf64_alpha_create_got_section (abfd, info))
1817 s = bfd_make_section(abfd, ".rela.got");
1819 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1822 | SEC_LINKER_CREATED
1824 || !bfd_set_section_alignment (abfd, s, 3))
1827 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1828 dynobj's .got section. We don't do this in the linker script
1829 because we don't want to define the symbol if we are not creating
1830 a global offset table. */
1832 if (!(_bfd_generic_link_add_one_symbol
1833 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1834 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1835 false, get_elf_backend_data (abfd)->collect,
1836 (struct bfd_link_hash_entry **) &h)))
1838 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1839 h->type = STT_OBJECT;
1842 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1845 elf_hash_table (info)->hgot = h;
1850 /* Read ECOFF debugging information from a .mdebug section into a
1851 ecoff_debug_info structure. */
1854 elf64_alpha_read_ecoff_info (abfd, section, debug)
1857 struct ecoff_debug_info *debug;
1860 const struct ecoff_debug_swap *swap;
1861 char *ext_hdr = NULL;
1863 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1864 memset (debug, 0, sizeof (*debug));
1866 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1867 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1870 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1871 swap->external_hdr_size)
1875 symhdr = &debug->symbolic_header;
1876 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1878 /* The symbolic header contains absolute file offsets and sizes to
1880 #define READ(ptr, offset, count, size, type) \
1881 if (symhdr->count == 0) \
1882 debug->ptr = NULL; \
1885 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1886 debug->ptr = (type) bfd_malloc (amt); \
1887 if (debug->ptr == NULL) \
1888 goto error_return; \
1889 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1890 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1891 goto error_return; \
1894 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1895 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1896 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1897 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1898 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1899 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1901 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1902 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1903 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1904 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1905 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1909 debug->adjust = NULL;
1914 if (ext_hdr != NULL)
1916 if (debug->line != NULL)
1918 if (debug->external_dnr != NULL)
1919 free (debug->external_dnr);
1920 if (debug->external_pdr != NULL)
1921 free (debug->external_pdr);
1922 if (debug->external_sym != NULL)
1923 free (debug->external_sym);
1924 if (debug->external_opt != NULL)
1925 free (debug->external_opt);
1926 if (debug->external_aux != NULL)
1927 free (debug->external_aux);
1928 if (debug->ss != NULL)
1930 if (debug->ssext != NULL)
1931 free (debug->ssext);
1932 if (debug->external_fdr != NULL)
1933 free (debug->external_fdr);
1934 if (debug->external_rfd != NULL)
1935 free (debug->external_rfd);
1936 if (debug->external_ext != NULL)
1937 free (debug->external_ext);
1941 /* Alpha ELF local labels start with '$'. */
1944 elf64_alpha_is_local_label_name (abfd, name)
1945 bfd *abfd ATTRIBUTE_UNUSED;
1948 return name[0] == '$';
1951 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1952 routine in order to handle the ECOFF debugging information. We
1953 still call this mips_elf_find_line because of the slot
1954 find_line_info in elf_obj_tdata is declared that way. */
1956 struct mips_elf_find_line
1958 struct ecoff_debug_info d;
1959 struct ecoff_find_line i;
1963 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
1964 functionname_ptr, line_ptr)
1969 const char **filename_ptr;
1970 const char **functionname_ptr;
1971 unsigned int *line_ptr;
1975 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1976 filename_ptr, functionname_ptr,
1978 &elf_tdata (abfd)->dwarf2_find_line_info))
1981 msec = bfd_get_section_by_name (abfd, ".mdebug");
1985 struct mips_elf_find_line *fi;
1986 const struct ecoff_debug_swap * const swap =
1987 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1989 /* If we are called during a link, alpha_elf_final_link may have
1990 cleared the SEC_HAS_CONTENTS field. We force it back on here
1991 if appropriate (which it normally will be). */
1992 origflags = msec->flags;
1993 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1994 msec->flags |= SEC_HAS_CONTENTS;
1996 fi = elf_tdata (abfd)->find_line_info;
1999 bfd_size_type external_fdr_size;
2002 struct fdr *fdr_ptr;
2003 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2005 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2008 msec->flags = origflags;
2012 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2014 msec->flags = origflags;
2018 /* Swap in the FDR information. */
2019 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2020 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2021 if (fi->d.fdr == NULL)
2023 msec->flags = origflags;
2026 external_fdr_size = swap->external_fdr_size;
2027 fdr_ptr = fi->d.fdr;
2028 fraw_src = (char *) fi->d.external_fdr;
2029 fraw_end = (fraw_src
2030 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2031 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2032 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2034 elf_tdata (abfd)->find_line_info = fi;
2036 /* Note that we don't bother to ever free this information.
2037 find_nearest_line is either called all the time, as in
2038 objdump -l, so the information should be saved, or it is
2039 rarely called, as in ld error messages, so the memory
2040 wasted is unimportant. Still, it would probably be a
2041 good idea for free_cached_info to throw it away. */
2044 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2045 &fi->i, filename_ptr, functionname_ptr,
2048 msec->flags = origflags;
2052 msec->flags = origflags;
2055 /* Fall back on the generic ELF find_nearest_line routine. */
2057 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2058 filename_ptr, functionname_ptr,
2062 /* Structure used to pass information to alpha_elf_output_extsym. */
2067 struct bfd_link_info *info;
2068 struct ecoff_debug_info *debug;
2069 const struct ecoff_debug_swap *swap;
2074 elf64_alpha_output_extsym (h, data)
2075 struct alpha_elf_link_hash_entry *h;
2078 struct extsym_info *einfo = (struct extsym_info *) data;
2080 asection *sec, *output_section;
2082 if (h->root.indx == -2)
2084 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2085 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2086 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2087 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2089 else if (einfo->info->strip == strip_all
2090 || (einfo->info->strip == strip_some
2091 && bfd_hash_lookup (einfo->info->keep_hash,
2092 h->root.root.root.string,
2093 false, false) == NULL))
2101 if (h->esym.ifd == -2)
2104 h->esym.cobol_main = 0;
2105 h->esym.weakext = 0;
2106 h->esym.reserved = 0;
2107 h->esym.ifd = ifdNil;
2108 h->esym.asym.value = 0;
2109 h->esym.asym.st = stGlobal;
2111 if (h->root.root.type != bfd_link_hash_defined
2112 && h->root.root.type != bfd_link_hash_defweak)
2113 h->esym.asym.sc = scAbs;
2118 sec = h->root.root.u.def.section;
2119 output_section = sec->output_section;
2121 /* When making a shared library and symbol h is the one from
2122 the another shared library, OUTPUT_SECTION may be null. */
2123 if (output_section == NULL)
2124 h->esym.asym.sc = scUndefined;
2127 name = bfd_section_name (output_section->owner, output_section);
2129 if (strcmp (name, ".text") == 0)
2130 h->esym.asym.sc = scText;
2131 else if (strcmp (name, ".data") == 0)
2132 h->esym.asym.sc = scData;
2133 else if (strcmp (name, ".sdata") == 0)
2134 h->esym.asym.sc = scSData;
2135 else if (strcmp (name, ".rodata") == 0
2136 || strcmp (name, ".rdata") == 0)
2137 h->esym.asym.sc = scRData;
2138 else if (strcmp (name, ".bss") == 0)
2139 h->esym.asym.sc = scBss;
2140 else if (strcmp (name, ".sbss") == 0)
2141 h->esym.asym.sc = scSBss;
2142 else if (strcmp (name, ".init") == 0)
2143 h->esym.asym.sc = scInit;
2144 else if (strcmp (name, ".fini") == 0)
2145 h->esym.asym.sc = scFini;
2147 h->esym.asym.sc = scAbs;
2151 h->esym.asym.reserved = 0;
2152 h->esym.asym.index = indexNil;
2155 if (h->root.root.type == bfd_link_hash_common)
2156 h->esym.asym.value = h->root.root.u.c.size;
2157 else if (h->root.root.type == bfd_link_hash_defined
2158 || h->root.root.type == bfd_link_hash_defweak)
2160 if (h->esym.asym.sc == scCommon)
2161 h->esym.asym.sc = scBss;
2162 else if (h->esym.asym.sc == scSCommon)
2163 h->esym.asym.sc = scSBss;
2165 sec = h->root.root.u.def.section;
2166 output_section = sec->output_section;
2167 if (output_section != NULL)
2168 h->esym.asym.value = (h->root.root.u.def.value
2169 + sec->output_offset
2170 + output_section->vma);
2172 h->esym.asym.value = 0;
2174 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2176 /* Set type and value for a symbol with a function stub. */
2177 h->esym.asym.st = stProc;
2178 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2180 h->esym.asym.value = 0;
2183 output_section = sec->output_section;
2184 if (output_section != NULL)
2185 h->esym.asym.value = (h->root.plt.offset
2186 + sec->output_offset
2187 + output_section->vma);
2189 h->esym.asym.value = 0;
2193 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2194 h->root.root.root.string,
2197 einfo->failed = true;
2204 /* FIXME: Create a runtime procedure table from the .mdebug section.
2207 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2210 struct bfd_link_info *info;
2212 struct ecoff_debug_info *debug;
2215 /* Handle dynamic relocations when doing an Alpha ELF link. */
2218 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2220 struct bfd_link_info *info;
2222 const Elf_Internal_Rela *relocs;
2226 const char *rel_sec_name;
2227 Elf_Internal_Shdr *symtab_hdr;
2228 struct alpha_elf_link_hash_entry **sym_hashes;
2229 struct alpha_elf_got_entry **local_got_entries;
2230 const Elf_Internal_Rela *rel, *relend;
2234 if (info->relocateable)
2237 dynobj = elf_hash_table(info)->dynobj;
2239 elf_hash_table(info)->dynobj = dynobj = abfd;
2242 rel_sec_name = NULL;
2243 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2244 sym_hashes = alpha_elf_sym_hashes(abfd);
2245 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2248 relend = relocs + sec->reloc_count;
2249 for (rel = relocs; rel < relend; ++rel)
2251 unsigned long r_symndx, r_type;
2252 struct alpha_elf_link_hash_entry *h;
2254 r_symndx = ELF64_R_SYM (rel->r_info);
2255 if (r_symndx < symtab_hdr->sh_info)
2259 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2261 while (h->root.root.type == bfd_link_hash_indirect
2262 || h->root.root.type == bfd_link_hash_warning)
2263 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2265 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2267 r_type = ELF64_R_TYPE (rel->r_info);
2271 case R_ALPHA_LITERAL:
2273 struct alpha_elf_got_entry *gotent;
2278 /* Search for and possibly create a got entry. */
2279 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2280 if (gotent->gotobj == abfd &&
2281 gotent->addend == rel->r_addend)
2286 amt = sizeof (struct alpha_elf_got_entry);
2287 gotent = ((struct alpha_elf_got_entry *)
2288 bfd_alloc (abfd, amt));
2292 gotent->gotobj = abfd;
2293 gotent->addend = rel->r_addend;
2294 gotent->got_offset = -1;
2296 gotent->use_count = 1;
2298 gotent->next = h->got_entries;
2299 h->got_entries = gotent;
2301 alpha_elf_tdata (abfd)->total_got_entries++;
2304 gotent->use_count += 1;
2308 /* This is a local .got entry -- record for merge. */
2309 if (!local_got_entries)
2312 size = symtab_hdr->sh_info;
2313 size *= sizeof (struct alpha_elf_got_entry *);
2315 local_got_entries = ((struct alpha_elf_got_entry **)
2316 bfd_alloc (abfd, size));
2317 if (!local_got_entries)
2320 memset (local_got_entries, 0, (size_t) size);
2321 alpha_elf_tdata (abfd)->local_got_entries =
2325 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2326 gotent != NULL && gotent->addend != rel->r_addend;
2327 gotent = gotent->next)
2331 amt = sizeof (struct alpha_elf_got_entry);
2332 gotent = ((struct alpha_elf_got_entry *)
2333 bfd_alloc (abfd, amt));
2337 gotent->gotobj = abfd;
2338 gotent->addend = rel->r_addend;
2339 gotent->got_offset = -1;
2341 gotent->use_count = 1;
2343 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2344 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2346 alpha_elf_tdata(abfd)->total_got_entries++;
2347 alpha_elf_tdata(abfd)->n_local_got_entries++;
2350 gotent->use_count += 1;
2353 /* Remember how this literal is used from its LITUSEs.
2354 This will be important when it comes to decide if we can
2355 create a .plt entry for a function symbol. */
2357 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2362 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2363 flags |= 1 << rel->r_addend;
2365 while (rel+1 < relend &&
2366 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2370 /* No LITUSEs -- presumably the address is not being
2371 loaded for nothing. */
2372 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2375 gotent->flags |= flags;
2378 /* Make a guess as to whether a .plt entry will be needed. */
2379 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2380 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2382 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2387 case R_ALPHA_GPDISP:
2388 case R_ALPHA_GPREL16:
2389 case R_ALPHA_GPREL32:
2390 case R_ALPHA_GPRELHIGH:
2391 case R_ALPHA_GPRELLOW:
2392 /* We don't actually use the .got here, but the sections must
2393 be created before the linker maps input sections to output
2397 if (!elf64_alpha_create_got_section (abfd, info))
2400 /* Make sure the object's gotobj is set to itself so
2401 that we default to every object with its own .got.
2402 We'll merge .gots later once we've collected each
2404 alpha_elf_tdata(abfd)->gotobj = abfd;
2410 case R_ALPHA_SREL16:
2411 case R_ALPHA_SREL32:
2412 case R_ALPHA_SREL64:
2417 case R_ALPHA_REFLONG:
2418 case R_ALPHA_REFQUAD:
2419 if (rel_sec_name == NULL)
2421 rel_sec_name = (bfd_elf_string_from_elf_section
2422 (abfd, elf_elfheader(abfd)->e_shstrndx,
2423 elf_section_data(sec)->rel_hdr.sh_name));
2424 if (rel_sec_name == NULL)
2427 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2428 && strcmp (bfd_get_section_name (abfd, sec),
2429 rel_sec_name+5) == 0);
2432 /* We need to create the section here now whether we eventually
2433 use it or not so that it gets mapped to an output section by
2434 the linker. If not used, we'll kill it in
2435 size_dynamic_sections. */
2438 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2443 sreloc = bfd_make_section (dynobj, rel_sec_name);
2444 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2445 | SEC_LINKER_CREATED | SEC_READONLY);
2446 if (sec->flags & SEC_ALLOC)
2447 flags |= SEC_ALLOC | SEC_LOAD;
2449 || !bfd_set_section_flags (dynobj, sreloc, flags)
2450 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2457 /* Since we havn't seen all of the input symbols yet, we
2458 don't know whether we'll actually need a dynamic relocation
2459 entry for this reloc. So make a record of it. Once we
2460 find out if this thing needs dynamic relocation we'll
2461 expand the relocation sections by the appropriate amount. */
2463 struct alpha_elf_reloc_entry *rent;
2465 for (rent = h->reloc_entries; rent; rent = rent->next)
2466 if (rent->rtype == r_type && rent->srel == sreloc)
2471 amt = sizeof (struct alpha_elf_reloc_entry);
2472 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
2476 rent->srel = sreloc;
2477 rent->rtype = r_type;
2479 rent->reltext = (sec->flags & SEC_READONLY) != 0;
2481 rent->next = h->reloc_entries;
2482 h->reloc_entries = rent;
2487 else if (info->shared && (sec->flags & SEC_ALLOC))
2489 /* If this is a shared library, and the section is to be
2490 loaded into memory, we need a RELATIVE reloc. */
2491 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2492 if (sec->flags & SEC_READONLY)
2493 info->flags |= DF_TEXTREL;
2502 /* Adjust a symbol defined by a dynamic object and referenced by a
2503 regular object. The current definition is in some section of the
2504 dynamic object, but we're not including those sections. We have to
2505 change the definition to something the rest of the link can
2509 elf64_alpha_adjust_dynamic_symbol (info, h)
2510 struct bfd_link_info *info;
2511 struct elf_link_hash_entry *h;
2515 struct alpha_elf_link_hash_entry *ah;
2517 dynobj = elf_hash_table(info)->dynobj;
2518 ah = (struct alpha_elf_link_hash_entry *)h;
2520 /* Now that we've seen all of the input symbols, finalize our decision
2521 about whether this symbol should get a .plt entry. */
2523 if (h->root.type != bfd_link_hash_undefweak
2524 && alpha_elf_dynamic_symbol_p (h, info)
2525 && ((h->type == STT_FUNC
2526 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2527 || (h->type == STT_NOTYPE
2528 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2529 /* Don't prevent otherwise valid programs from linking by attempting
2530 to create a new .got entry somewhere. A Correct Solution would be
2531 to add a new .got section to a new object file and let it be merged
2532 somewhere later. But for now don't bother. */
2535 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2537 s = bfd_get_section_by_name(dynobj, ".plt");
2538 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2541 /* The first bit of the .plt is reserved. */
2542 if (s->_raw_size == 0)
2543 s->_raw_size = PLT_HEADER_SIZE;
2545 h->plt.offset = s->_raw_size;
2546 s->_raw_size += PLT_ENTRY_SIZE;
2548 /* If this symbol is not defined in a regular file, and we are not
2549 generating a shared library, then set the symbol to the location
2550 in the .plt. This is required to make function pointers compare
2551 equal between the normal executable and the shared library. */
2553 && h->root.type != bfd_link_hash_defweak)
2555 h->root.u.def.section = s;
2556 h->root.u.def.value = h->plt.offset;
2559 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2560 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2561 BFD_ASSERT (s != NULL);
2562 s->_raw_size += sizeof (Elf64_External_Rela);
2567 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2569 /* If this is a weak symbol, and there is a real definition, the
2570 processor independent code will have arranged for us to see the
2571 real definition first, and we can just use the same value. */
2572 if (h->weakdef != NULL)
2574 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2575 || h->weakdef->root.type == bfd_link_hash_defweak);
2576 h->root.u.def.section = h->weakdef->root.u.def.section;
2577 h->root.u.def.value = h->weakdef->root.u.def.value;
2581 /* This is a reference to a symbol defined by a dynamic object which
2582 is not a function. The Alpha, since it uses .got entries for all
2583 symbols even in regular objects, does not need the hackery of a
2584 .dynbss section and COPY dynamic relocations. */
2589 /* Symbol versioning can create new symbols, and make our old symbols
2590 indirect to the new ones. Consolidate the got and reloc information
2591 in these situations. */
2594 elf64_alpha_merge_ind_symbols (hi, dummy)
2595 struct alpha_elf_link_hash_entry *hi;
2596 PTR dummy ATTRIBUTE_UNUSED;
2598 struct alpha_elf_link_hash_entry *hs;
2600 if (hi->root.root.type != bfd_link_hash_indirect)
2604 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2605 } while (hs->root.root.type == bfd_link_hash_indirect);
2607 /* Merge the flags. Whee. */
2609 hs->flags |= hi->flags;
2611 /* Merge the .got entries. Cannibalize the old symbol's list in
2612 doing so, since we don't need it anymore. */
2614 if (hs->got_entries == NULL)
2615 hs->got_entries = hi->got_entries;
2618 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2620 gsh = hs->got_entries;
2621 for (gi = hi->got_entries; gi ; gi = gin)
2624 for (gs = gsh; gs ; gs = gs->next)
2625 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2627 gi->next = hs->got_entries;
2628 hs->got_entries = gi;
2632 hi->got_entries = NULL;
2634 /* And similar for the reloc entries. */
2636 if (hs->reloc_entries == NULL)
2637 hs->reloc_entries = hi->reloc_entries;
2640 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2642 rsh = hs->reloc_entries;
2643 for (ri = hi->reloc_entries; ri ; ri = rin)
2646 for (rs = rsh; rs ; rs = rs->next)
2647 if (ri->rtype == rs->rtype)
2649 rs->count += ri->count;
2652 ri->next = hs->reloc_entries;
2653 hs->reloc_entries = ri;
2657 hi->reloc_entries = NULL;
2662 /* Is it possible to merge two object file's .got tables? */
2665 elf64_alpha_can_merge_gots (a, b)
2668 int total = alpha_elf_tdata (a)->total_got_entries;
2671 /* Trivial quick fallout test. */
2672 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2675 /* By their nature, local .got entries cannot be merged. */
2676 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2679 /* Failing the common trivial comparison, we must effectively
2680 perform the merge. Not actually performing the merge means that
2681 we don't have to store undo information in case we fail. */
2682 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2684 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2685 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2688 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2689 for (i = 0; i < n; ++i)
2691 struct alpha_elf_got_entry *ae, *be;
2692 struct alpha_elf_link_hash_entry *h;
2695 while (h->root.root.type == bfd_link_hash_indirect
2696 || h->root.root.type == bfd_link_hash_warning)
2697 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2699 for (be = h->got_entries; be ; be = be->next)
2701 if (be->use_count == 0)
2703 if (be->gotobj != b)
2706 for (ae = h->got_entries; ae ; ae = ae->next)
2707 if (ae->gotobj == a && ae->addend == be->addend)
2710 if (++total > MAX_GOT_ENTRIES)
2720 /* Actually merge two .got tables. */
2723 elf64_alpha_merge_gots (a, b)
2726 int total = alpha_elf_tdata (a)->total_got_entries;
2729 /* Remember local expansion. */
2731 int e = alpha_elf_tdata (b)->n_local_got_entries;
2733 alpha_elf_tdata (a)->n_local_got_entries += e;
2736 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2738 struct alpha_elf_got_entry **local_got_entries;
2739 struct alpha_elf_link_hash_entry **hashes;
2740 Elf_Internal_Shdr *symtab_hdr;
2743 /* Let the local .got entries know they are part of a new subsegment. */
2744 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2745 if (local_got_entries)
2747 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2748 for (i = 0; i < n; ++i)
2750 struct alpha_elf_got_entry *ent;
2751 for (ent = local_got_entries[i]; ent; ent = ent->next)
2756 /* Merge the global .got entries. */
2757 hashes = alpha_elf_sym_hashes (bsub);
2758 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2760 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2761 for (i = 0; i < n; ++i)
2763 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2764 struct alpha_elf_link_hash_entry *h;
2767 while (h->root.root.type == bfd_link_hash_indirect
2768 || h->root.root.type == bfd_link_hash_warning)
2769 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2771 start = &h->got_entries;
2772 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2774 if (be->use_count == 0)
2779 if (be->gotobj != b)
2782 for (ae = *start; ae ; ae = ae->next)
2783 if (ae->gotobj == a && ae->addend == be->addend)
2785 ae->flags |= be->flags;
2786 ae->use_count += be->use_count;
2797 alpha_elf_tdata (bsub)->gotobj = a;
2799 alpha_elf_tdata (a)->total_got_entries = total;
2801 /* Merge the two in_got chains. */
2806 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2809 alpha_elf_tdata (bsub)->in_got_link_next = b;
2813 /* Calculate the offsets for the got entries. */
2816 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2817 struct alpha_elf_link_hash_entry *h;
2818 PTR arg ATTRIBUTE_UNUSED;
2820 struct alpha_elf_got_entry *gotent;
2822 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2823 if (gotent->use_count > 0)
2826 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2828 gotent->got_offset = *plge;
2836 elf64_alpha_calc_got_offsets (info)
2837 struct bfd_link_info *info;
2839 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2841 /* First, zero out the .got sizes, as we may be recalculating the
2842 .got after optimizing it. */
2843 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2844 alpha_elf_tdata(i)->got->_raw_size = 0;
2846 /* Next, fill in the offsets for all the global entries. */
2847 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2848 elf64_alpha_calc_got_offsets_for_symbol,
2851 /* Finally, fill in the offsets for the local entries. */
2852 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2854 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2857 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2859 struct alpha_elf_got_entry **local_got_entries, *gotent;
2862 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2863 if (!local_got_entries)
2866 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2867 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2868 if (gotent->use_count > 0)
2870 gotent->got_offset = got_offset;
2875 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2876 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2880 /* Constructs the gots. */
2883 elf64_alpha_size_got_sections (output_bfd, info)
2884 bfd *output_bfd ATTRIBUTE_UNUSED;
2885 struct bfd_link_info *info;
2887 bfd *i, *got_list, *cur_got_obj = NULL;
2888 int something_changed = 0;
2890 got_list = alpha_elf_hash_table (info)->got_list;
2892 /* On the first time through, pretend we have an existing got list
2893 consisting of all of the input files. */
2894 if (got_list == NULL)
2896 for (i = info->input_bfds; i ; i = i->link_next)
2898 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2899 if (this_got == NULL)
2902 /* We are assuming no merging has yet ocurred. */
2903 BFD_ASSERT (this_got == i);
2905 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2907 /* Yikes! A single object file has too many entries. */
2908 (*_bfd_error_handler)
2909 (_("%s: .got subsegment exceeds 64K (size %d)"),
2910 bfd_archive_filename (i),
2911 alpha_elf_tdata (this_got)->total_got_entries * 8);
2915 if (got_list == NULL)
2916 got_list = this_got;
2918 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2919 cur_got_obj = this_got;
2922 /* Strange degenerate case of no got references. */
2923 if (got_list == NULL)
2926 alpha_elf_hash_table (info)->got_list = got_list;
2928 /* Force got offsets to be recalculated. */
2929 something_changed = 1;
2932 cur_got_obj = got_list;
2933 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2936 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2938 elf64_alpha_merge_gots (cur_got_obj, i);
2939 i = alpha_elf_tdata(i)->got_link_next;
2940 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2941 something_changed = 1;
2946 i = alpha_elf_tdata(i)->got_link_next;
2950 /* Once the gots have been merged, fill in the got offsets for
2951 everything therein. */
2952 if (1 || something_changed)
2953 elf64_alpha_calc_got_offsets (info);
2959 elf64_alpha_always_size_sections (output_bfd, info)
2961 struct bfd_link_info *info;
2965 if (info->relocateable)
2968 /* First, take care of the indirect symbols created by versioning. */
2969 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2970 elf64_alpha_merge_ind_symbols,
2973 if (!elf64_alpha_size_got_sections (output_bfd, info))
2976 /* Allocate space for all of the .got subsections. */
2977 i = alpha_elf_hash_table (info)->got_list;
2978 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2980 asection *s = alpha_elf_tdata(i)->got;
2981 if (s->_raw_size > 0)
2983 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
2984 if (s->contents == NULL)
2992 /* Work out the sizes of the dynamic relocation entries. */
2995 elf64_alpha_calc_dynrel_sizes (h, info)
2996 struct alpha_elf_link_hash_entry *h;
2997 struct bfd_link_info *info;
2999 /* If the symbol was defined as a common symbol in a regular object
3000 file, and there was no definition in any dynamic object, then the
3001 linker will have allocated space for the symbol in a common
3002 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3003 set. This is done for dynamic symbols in
3004 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3005 symbols, somehow. */
3006 if (((h->root.elf_link_hash_flags
3007 & (ELF_LINK_HASH_DEF_REGULAR
3008 | ELF_LINK_HASH_REF_REGULAR
3009 | ELF_LINK_HASH_DEF_DYNAMIC))
3010 == ELF_LINK_HASH_REF_REGULAR)
3011 && (h->root.root.type == bfd_link_hash_defined
3012 || h->root.root.type == bfd_link_hash_defweak)
3013 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3015 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3018 /* If the symbol is dynamic, we'll need all the relocations in their
3019 natural form. If this is a shared object, and it has been forced
3020 local, we'll need the same number of RELATIVE relocations. */
3022 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3024 struct alpha_elf_reloc_entry *relent;
3026 struct alpha_elf_got_entry *gotent;
3027 bfd_size_type count;
3030 for (relent = h->reloc_entries; relent; relent = relent->next)
3031 if (relent->rtype == R_ALPHA_REFLONG
3032 || relent->rtype == R_ALPHA_REFQUAD)
3034 relent->srel->_raw_size +=
3035 sizeof (Elf64_External_Rela) * relent->count;
3036 if (relent->reltext)
3037 info->flags |= DT_TEXTREL;
3040 dynobj = elf_hash_table(info)->dynobj;
3043 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3046 /* If we are using a .plt entry, subtract one, as the first
3047 reference uses a .rela.plt entry instead. */
3048 if (h->root.plt.offset != MINUS_ONE)
3053 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3054 BFD_ASSERT (srel != NULL);
3055 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3062 /* Set the sizes of the dynamic sections. */
3065 elf64_alpha_size_dynamic_sections (output_bfd, info)
3066 bfd *output_bfd ATTRIBUTE_UNUSED;
3067 struct bfd_link_info *info;
3073 dynobj = elf_hash_table(info)->dynobj;
3074 BFD_ASSERT(dynobj != NULL);
3076 if (elf_hash_table (info)->dynamic_sections_created)
3078 /* Set the contents of the .interp section to the interpreter. */
3081 s = bfd_get_section_by_name (dynobj, ".interp");
3082 BFD_ASSERT (s != NULL);
3083 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3084 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3087 /* Now that we've seen all of the input files, we can decide which
3088 symbols need dynamic relocation entries and which don't. We've
3089 collected information in check_relocs that we can now apply to
3090 size the dynamic relocation sections. */
3091 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3092 elf64_alpha_calc_dynrel_sizes,
3095 /* When building shared libraries, each local .got entry needs a
3101 bfd_size_type count;
3103 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3104 BFD_ASSERT (srel != NULL);
3106 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3108 i = alpha_elf_tdata(i)->got_link_next)
3109 count += alpha_elf_tdata(i)->n_local_got_entries;
3111 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3114 /* else we're not dynamic and by definition we don't need such things. */
3116 /* The check_relocs and adjust_dynamic_symbol entry points have
3117 determined the sizes of the various dynamic sections. Allocate
3120 for (s = dynobj->sections; s != NULL; s = s->next)
3125 if (!(s->flags & SEC_LINKER_CREATED))
3128 /* It's OK to base decisions on the section name, because none
3129 of the dynobj section names depend upon the input files. */
3130 name = bfd_get_section_name (dynobj, s);
3132 /* If we don't need this section, strip it from the output file.
3133 This is to handle .rela.bss and .rela.plt. We must create it
3134 in create_dynamic_sections, because it must be created before
3135 the linker maps input sections to output sections. The
3136 linker does that before adjust_dynamic_symbol is called, and
3137 it is that function which decides whether anything needs to
3138 go into these sections. */
3142 if (strncmp (name, ".rela", 5) == 0)
3144 strip = (s->_raw_size == 0);
3148 if (strcmp(name, ".rela.plt") == 0)
3151 /* We use the reloc_count field as a counter if we need
3152 to copy relocs into the output file. */
3156 else if (strcmp (name, ".plt") != 0)
3158 /* It's not one of our dynamic sections, so don't allocate space. */
3163 _bfd_strip_section_from_output (info, s);
3166 /* Allocate memory for the section contents. */
3167 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3168 if (s->contents == NULL && s->_raw_size != 0)
3173 if (elf_hash_table (info)->dynamic_sections_created)
3175 /* Add some entries to the .dynamic section. We fill in the
3176 values later, in elf64_alpha_finish_dynamic_sections, but we
3177 must add the entries now so that we get the correct size for
3178 the .dynamic section. The DT_DEBUG entry is filled in by the
3179 dynamic linker and used by the debugger. */
3180 #define add_dynamic_entry(TAG, VAL) \
3181 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3185 if (!add_dynamic_entry (DT_DEBUG, 0))
3189 if (!add_dynamic_entry (DT_PLTGOT, 0))
3194 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3195 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3196 || !add_dynamic_entry (DT_JMPREL, 0))
3200 if (!add_dynamic_entry (DT_RELA, 0)
3201 || !add_dynamic_entry (DT_RELASZ, 0)
3202 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3205 if (info->flags & DF_TEXTREL)
3207 if (!add_dynamic_entry (DT_TEXTREL, 0))
3211 #undef add_dynamic_entry
3216 /* Relocate an Alpha ELF section. */
3219 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3220 contents, relocs, local_syms, local_sections)
3222 struct bfd_link_info *info;
3224 asection *input_section;
3226 Elf_Internal_Rela *relocs;
3227 Elf_Internal_Sym *local_syms;
3228 asection **local_sections;
3230 Elf_Internal_Shdr *symtab_hdr;
3231 Elf_Internal_Rela *rel;
3232 Elf_Internal_Rela *relend;
3233 asection *sec, *sgot, *srel, *srelgot;
3234 bfd *dynobj, *gotobj;
3236 boolean ret_val = true;
3238 srelgot = srel = NULL;
3239 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3240 dynobj = elf_hash_table (info)->dynobj;
3243 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3246 /* Find the gp value for this input bfd. */
3249 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3252 sgot = alpha_elf_tdata (gotobj)->got;
3253 gp = _bfd_get_gp_value (gotobj);
3256 gp = (sgot->output_section->vma
3257 + sgot->output_offset
3259 _bfd_set_gp_value (gotobj, gp);
3264 relend = relocs + input_section->reloc_count;
3265 for (; rel < relend; rel++)
3268 reloc_howto_type *howto;
3269 unsigned long r_symndx;
3270 struct alpha_elf_link_hash_entry *h;
3271 Elf_Internal_Sym *sym;
3274 bfd_reloc_status_type r;
3276 r_type = ELF64_R_TYPE(rel->r_info);
3277 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3279 bfd_set_error (bfd_error_bad_value);
3282 howto = elf64_alpha_howto_table + r_type;
3284 r_symndx = ELF64_R_SYM(rel->r_info);
3286 if (info->relocateable)
3288 /* This is a relocateable link. We don't have to change
3289 anything, unless the reloc is against a section symbol,
3290 in which case we have to adjust according to where the
3291 section symbol winds up in the output section. */
3293 /* The symbol associated with GPDISP and LITUSE is
3294 immaterial. Only the addend is significant. */
3295 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3298 if (r_symndx < symtab_hdr->sh_info)
3300 sym = local_syms + r_symndx;
3301 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3303 sec = local_sections[r_symndx];
3304 rel->r_addend += sec->output_offset + sym->st_value;
3311 /* This is a final link. */
3317 if (r_symndx < symtab_hdr->sh_info)
3319 sym = local_syms + r_symndx;
3320 sec = local_sections[r_symndx];
3321 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3325 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3327 while (h->root.root.type == bfd_link_hash_indirect
3328 || h->root.root.type == bfd_link_hash_warning)
3329 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3331 if (h->root.root.type == bfd_link_hash_defined
3332 || h->root.root.type == bfd_link_hash_defweak)
3334 sec = h->root.root.u.def.section;
3336 if (sec->output_section == NULL)
3340 relocation = (h->root.root.u.def.value
3341 + sec->output_section->vma
3342 + sec->output_offset);
3345 else if (h->root.root.type == bfd_link_hash_undefweak)
3347 else if (info->shared
3348 && (!info->symbolic || info->allow_shlib_undefined)
3349 && !info->no_undefined
3350 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3354 if (!((*info->callbacks->undefined_symbol)
3355 (info, h->root.root.root.string, input_bfd,
3356 input_section, rel->r_offset,
3357 (!info->shared || info->no_undefined
3358 || ELF_ST_VISIBILITY (h->root.other)))))
3363 addend = rel->r_addend;
3367 case R_ALPHA_GPDISP:
3369 bfd_byte *p_ldah, *p_lda;
3371 BFD_ASSERT(gp != 0);
3373 relocation = (input_section->output_section->vma
3374 + input_section->output_offset
3377 p_ldah = contents + rel->r_offset - input_section->vma;
3378 p_lda = p_ldah + rel->r_addend;
3380 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3385 case R_ALPHA_LITERAL:
3387 struct alpha_elf_got_entry *gotent;
3388 boolean dynamic_symbol;
3390 BFD_ASSERT(sgot != NULL);
3391 BFD_ASSERT(gp != 0);
3395 gotent = h->got_entries;
3396 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3400 gotent = (alpha_elf_tdata(input_bfd)->
3401 local_got_entries[r_symndx]);
3402 dynamic_symbol = false;
3405 BFD_ASSERT(gotent != NULL);
3407 while (gotent->gotobj != gotobj || gotent->addend != addend)
3408 gotent = gotent->next;
3410 BFD_ASSERT(gotent->use_count >= 1);
3412 /* Initialize the .got entry's value. */
3413 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3415 bfd_put_64 (output_bfd, relocation + addend,
3416 sgot->contents + gotent->got_offset);
3418 /* If the symbol has been forced local, output a
3419 RELATIVE reloc, otherwise it will be handled in
3420 finish_dynamic_symbol. */
3421 if (info->shared && !dynamic_symbol)
3423 Elf_Internal_Rela outrel;
3425 BFD_ASSERT(srelgot != NULL);
3427 outrel.r_offset = (sgot->output_section->vma
3428 + sgot->output_offset
3429 + gotent->got_offset);
3430 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3431 outrel.r_addend = relocation + addend;
3433 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3434 ((Elf64_External_Rela *)
3436 + srelgot->reloc_count++);
3437 BFD_ASSERT (sizeof (Elf64_External_Rela)
3438 * srelgot->reloc_count
3439 <= srelgot->_cooked_size);
3442 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3445 /* Figure the gprel relocation. */
3447 relocation = (sgot->output_section->vma
3448 + sgot->output_offset
3449 + gotent->got_offset);
3452 /* overflow handled by _bfd_final_link_relocate */
3455 case R_ALPHA_GPREL16:
3456 case R_ALPHA_GPREL32:
3457 case R_ALPHA_GPRELLOW:
3458 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3460 (*_bfd_error_handler)
3461 (_("%s: gp-relative relocation against dynamic symbol %s"),
3462 bfd_archive_filename (input_bfd), h->root.root.root.string);
3465 BFD_ASSERT(gp != 0);
3469 case R_ALPHA_GPRELHIGH:
3470 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3472 (*_bfd_error_handler)
3473 (_("%s: gp-relative relocation against dynamic symbol %s"),
3474 bfd_archive_filename (input_bfd), h->root.root.root.string);
3477 BFD_ASSERT(gp != 0);
3479 relocation += addend;
3481 relocation = (((bfd_signed_vma) relocation >> 16)
3482 + ((relocation >> 15) & 1));
3486 /* A call to a dynamic symbol is definitely out of range of
3487 the 16-bit displacement. Don't bother writing anything. */
3488 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3495 case R_ALPHA_BRADDR:
3496 /* The regular PC-relative stuff measures from the start of
3497 the instruction rather than the end. */
3501 case R_ALPHA_REFLONG:
3502 case R_ALPHA_REFQUAD:
3504 Elf_Internal_Rela outrel;
3507 /* Careful here to remember RELATIVE relocations for global
3508 variables for symbolic shared objects. */
3510 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3512 BFD_ASSERT(h->root.dynindx != -1);
3513 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3514 outrel.r_addend = addend;
3515 addend = 0, relocation = 0;
3517 else if (info->shared
3519 && (input_section->flags & SEC_ALLOC))
3521 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3522 outrel.r_addend = relocation + addend;
3531 name = (bfd_elf_string_from_elf_section
3532 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3533 elf_section_data(input_section)->rel_hdr.sh_name));
3534 BFD_ASSERT(name != NULL);
3536 srel = bfd_get_section_by_name (dynobj, name);
3537 BFD_ASSERT(srel != NULL);
3542 if (elf_section_data (input_section)->stab_info == NULL)
3543 outrel.r_offset = rel->r_offset;
3548 off = (_bfd_stab_section_offset
3549 (output_bfd, &elf_hash_table (info)->stab_info,
3551 &elf_section_data (input_section)->stab_info,
3553 if (off == (bfd_vma) -1)
3555 outrel.r_offset = off;
3559 outrel.r_offset += (input_section->output_section->vma
3560 + input_section->output_offset);
3562 memset (&outrel, 0, sizeof outrel);
3564 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3565 ((Elf64_External_Rela *)
3567 + srel->reloc_count++);
3568 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3569 <= srel->_cooked_size);
3575 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3576 contents, rel->r_offset, relocation,
3586 case bfd_reloc_overflow:
3591 name = h->root.root.root.string;
3594 name = (bfd_elf_string_from_elf_section
3595 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3599 name = bfd_section_name (input_bfd, sec);
3601 if (! ((*info->callbacks->reloc_overflow)
3602 (info, name, howto->name, (bfd_vma) 0,
3603 input_bfd, input_section, rel->r_offset)))
3609 case bfd_reloc_outofrange:
3617 /* Finish up dynamic symbol handling. We set the contents of various
3618 dynamic sections here. */
3621 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3623 struct bfd_link_info *info;
3624 struct elf_link_hash_entry *h;
3625 Elf_Internal_Sym *sym;
3627 bfd *dynobj = elf_hash_table(info)->dynobj;
3629 if (h->plt.offset != MINUS_ONE)
3631 /* Fill in the .plt entry for this symbol. */
3632 asection *splt, *sgot, *srel;
3633 Elf_Internal_Rela outrel;
3634 bfd_vma got_addr, plt_addr;
3636 struct alpha_elf_got_entry *gotent;
3638 BFD_ASSERT (h->dynindx != -1);
3640 /* The first .got entry will be updated by the .plt with the
3641 address of the target function. */
3642 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3643 BFD_ASSERT (gotent && gotent->addend == 0);
3645 splt = bfd_get_section_by_name (dynobj, ".plt");
3646 BFD_ASSERT (splt != NULL);
3647 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3648 BFD_ASSERT (srel != NULL);
3649 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3650 BFD_ASSERT (sgot != NULL);
3652 got_addr = (sgot->output_section->vma
3653 + sgot->output_offset
3654 + gotent->got_offset);
3655 plt_addr = (splt->output_section->vma
3656 + splt->output_offset
3659 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3661 /* Fill in the entry in the procedure linkage table. */
3663 bfd_vma insn1, insn2, insn3;
3665 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3666 insn2 = PLT_ENTRY_WORD2;
3667 insn3 = PLT_ENTRY_WORD3;
3669 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3670 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3671 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3674 /* Fill in the entry in the .rela.plt section. */
3675 outrel.r_offset = got_addr;
3676 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3677 outrel.r_addend = 0;
3679 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3680 ((Elf64_External_Rela *)srel->contents
3683 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3685 /* Mark the symbol as undefined, rather than as defined in the
3686 .plt section. Leave the value alone. */
3687 sym->st_shndx = SHN_UNDEF;
3690 /* Fill in the entries in the .got. */
3691 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3693 /* Subsequent .got entries will continue to bounce through the .plt. */
3696 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3697 BFD_ASSERT (! info->shared || srel != NULL);
3699 gotent = gotent->next;
3702 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3703 BFD_ASSERT(sgot != NULL);
3704 BFD_ASSERT(gotent->addend == 0);
3706 bfd_put_64 (output_bfd, plt_addr,
3707 sgot->contents + gotent->got_offset);
3711 outrel.r_offset = (sgot->output_section->vma
3712 + sgot->output_offset
3713 + gotent->got_offset);
3714 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3715 outrel.r_addend = plt_addr;
3717 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3718 ((Elf64_External_Rela *)
3720 + srel->reloc_count++);
3721 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3722 <= srel->_cooked_size);
3725 gotent = gotent->next;
3727 while (gotent != NULL);
3730 else if (alpha_elf_dynamic_symbol_p (h, info))
3732 /* Fill in the dynamic relocations for this symbol's .got entries. */
3734 Elf_Internal_Rela outrel;
3735 struct alpha_elf_got_entry *gotent;
3737 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3738 BFD_ASSERT (srel != NULL);
3740 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3741 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3743 gotent = gotent->next)
3745 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3746 outrel.r_offset = (sgot->output_section->vma
3747 + sgot->output_offset
3748 + gotent->got_offset);
3749 outrel.r_addend = gotent->addend;
3751 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3752 ((Elf64_External_Rela *)srel->contents
3753 + srel->reloc_count++));
3754 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3755 <= srel->_cooked_size);
3759 /* Mark some specially defined symbols as absolute. */
3760 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3761 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3762 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3763 sym->st_shndx = SHN_ABS;
3768 /* Finish up the dynamic sections. */
3771 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3773 struct bfd_link_info *info;
3778 dynobj = elf_hash_table (info)->dynobj;
3779 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3781 if (elf_hash_table (info)->dynamic_sections_created)
3784 Elf64_External_Dyn *dyncon, *dynconend;
3786 splt = bfd_get_section_by_name (dynobj, ".plt");
3787 BFD_ASSERT (splt != NULL && sdyn != NULL);
3789 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3790 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3791 for (; dyncon < dynconend; dyncon++)
3793 Elf_Internal_Dyn dyn;
3797 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3812 /* My interpretation of the TIS v1.1 ELF document indicates
3813 that RELASZ should not include JMPREL. This is not what
3814 the rest of the BFD does. It is, however, what the
3815 glibc ld.so wants. Do this fixup here until we found
3816 out who is right. */
3817 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3821 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3826 s = bfd_get_section_by_name (output_bfd, name);
3827 dyn.d_un.d_ptr = (s ? s->vma : 0);
3831 s = bfd_get_section_by_name (output_bfd, name);
3833 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3837 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3840 /* Initialize the PLT0 entry */
3841 if (splt->_raw_size > 0)
3843 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3844 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3845 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3846 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3848 /* The next two words will be filled in by ld.so */
3849 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3850 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
3852 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3860 /* We need to use a special link routine to handle the .mdebug section.
3861 We need to merge all instances of these sections together, not write
3862 them all out sequentially. */
3865 elf64_alpha_final_link (abfd, info)
3867 struct bfd_link_info *info;
3870 struct bfd_link_order *p;
3871 asection *mdebug_sec;
3872 struct ecoff_debug_info debug;
3873 const struct ecoff_debug_swap *swap
3874 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3875 HDRR *symhdr = &debug.symbolic_header;
3876 PTR mdebug_handle = NULL;
3878 /* Go through the sections and collect the mdebug information. */
3880 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3882 if (strcmp (o->name, ".mdebug") == 0)
3884 struct extsym_info einfo;
3886 /* We have found the .mdebug section in the output file.
3887 Look through all the link_orders comprising it and merge
3888 the information together. */
3889 symhdr->magic = swap->sym_magic;
3890 /* FIXME: What should the version stamp be? */
3892 symhdr->ilineMax = 0;
3896 symhdr->isymMax = 0;
3897 symhdr->ioptMax = 0;
3898 symhdr->iauxMax = 0;
3900 symhdr->issExtMax = 0;
3903 symhdr->iextMax = 0;
3905 /* We accumulate the debugging information itself in the
3906 debug_info structure. */
3908 debug.external_dnr = NULL;
3909 debug.external_pdr = NULL;
3910 debug.external_sym = NULL;
3911 debug.external_opt = NULL;
3912 debug.external_aux = NULL;
3914 debug.ssext = debug.ssext_end = NULL;
3915 debug.external_fdr = NULL;
3916 debug.external_rfd = NULL;
3917 debug.external_ext = debug.external_ext_end = NULL;
3919 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
3920 if (mdebug_handle == (PTR) NULL)
3929 static const char * const name[] =
3931 ".text", ".init", ".fini", ".data",
3932 ".rodata", ".sdata", ".sbss", ".bss"
3934 static const int sc[] = { scText, scInit, scFini, scData,
3935 scRData, scSData, scSBss, scBss };
3938 esym.cobol_main = 0;
3942 esym.asym.iss = issNil;
3943 esym.asym.st = stLocal;
3944 esym.asym.reserved = 0;
3945 esym.asym.index = indexNil;
3946 for (i = 0; i < 8; i++)
3948 esym.asym.sc = sc[i];
3949 s = bfd_get_section_by_name (abfd, name[i]);
3952 esym.asym.value = s->vma;
3953 last = s->vma + s->_raw_size;
3956 esym.asym.value = last;
3958 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
3964 for (p = o->link_order_head;
3965 p != (struct bfd_link_order *) NULL;
3968 asection *input_section;
3970 const struct ecoff_debug_swap *input_swap;
3971 struct ecoff_debug_info input_debug;
3975 if (p->type != bfd_indirect_link_order)
3977 if (p->type == bfd_fill_link_order)
3982 input_section = p->u.indirect.section;
3983 input_bfd = input_section->owner;
3985 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
3986 || (get_elf_backend_data (input_bfd)
3987 ->elf_backend_ecoff_debug_swap) == NULL)
3989 /* I don't know what a non ALPHA ELF bfd would be
3990 doing with a .mdebug section, but I don't really
3991 want to deal with it. */
3995 input_swap = (get_elf_backend_data (input_bfd)
3996 ->elf_backend_ecoff_debug_swap);
3998 BFD_ASSERT (p->size == input_section->_raw_size);
4000 /* The ECOFF linking code expects that we have already
4001 read in the debugging information and set up an
4002 ecoff_debug_info structure, so we do that now. */
4003 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4007 if (! (bfd_ecoff_debug_accumulate
4008 (mdebug_handle, abfd, &debug, swap, input_bfd,
4009 &input_debug, input_swap, info)))
4012 /* Loop through the external symbols. For each one with
4013 interesting information, try to find the symbol in
4014 the linker global hash table and save the information
4015 for the output external symbols. */
4016 eraw_src = input_debug.external_ext;
4017 eraw_end = (eraw_src
4018 + (input_debug.symbolic_header.iextMax
4019 * input_swap->external_ext_size));
4021 eraw_src < eraw_end;
4022 eraw_src += input_swap->external_ext_size)
4026 struct alpha_elf_link_hash_entry *h;
4028 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4029 if (ext.asym.sc == scNil
4030 || ext.asym.sc == scUndefined
4031 || ext.asym.sc == scSUndefined)
4034 name = input_debug.ssext + ext.asym.iss;
4035 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4036 name, false, false, true);
4037 if (h == NULL || h->esym.ifd != -2)
4043 < input_debug.symbolic_header.ifdMax);
4044 ext.ifd = input_debug.ifdmap[ext.ifd];
4050 /* Free up the information we just read. */
4051 free (input_debug.line);
4052 free (input_debug.external_dnr);
4053 free (input_debug.external_pdr);
4054 free (input_debug.external_sym);
4055 free (input_debug.external_opt);
4056 free (input_debug.external_aux);
4057 free (input_debug.ss);
4058 free (input_debug.ssext);
4059 free (input_debug.external_fdr);
4060 free (input_debug.external_rfd);
4061 free (input_debug.external_ext);
4063 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4064 elf_link_input_bfd ignores this section. */
4065 input_section->flags &=~ SEC_HAS_CONTENTS;
4068 /* Build the external symbol information. */
4071 einfo.debug = &debug;
4073 einfo.failed = false;
4074 elf_link_hash_traverse (elf_hash_table (info),
4075 elf64_alpha_output_extsym,
4080 /* Set the size of the .mdebug section. */
4081 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4083 /* Skip this section later on (I don't think this currently
4084 matters, but someday it might). */
4085 o->link_order_head = (struct bfd_link_order *) NULL;
4091 /* Invoke the regular ELF backend linker to do all the work. */
4092 if (! bfd_elf64_bfd_final_link (abfd, info))
4095 /* Now write out the computed sections. */
4097 /* The .got subsections... */
4099 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4100 for (i = alpha_elf_hash_table(info)->got_list;
4102 i = alpha_elf_tdata(i)->got_link_next)
4106 /* elf_bfd_final_link already did everything in dynobj. */
4110 sgot = alpha_elf_tdata(i)->got;
4111 if (! bfd_set_section_contents (abfd, sgot->output_section,
4113 (file_ptr) sgot->output_offset,
4119 if (mdebug_sec != (asection *) NULL)
4121 BFD_ASSERT (abfd->output_has_begun);
4122 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4124 mdebug_sec->filepos))
4127 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4133 static enum elf_reloc_type_class
4134 elf64_alpha_reloc_type_class (rela)
4135 const Elf_Internal_Rela *rela;
4137 switch ((int) ELF64_R_TYPE (rela->r_info))
4139 case R_ALPHA_RELATIVE:
4140 return reloc_class_relative;
4141 case R_ALPHA_JMP_SLOT:
4142 return reloc_class_plt;
4144 return reloc_class_copy;
4146 return reloc_class_normal;
4150 /* ECOFF swapping routines. These are used when dealing with the
4151 .mdebug section, which is in the ECOFF debugging format. Copied
4152 from elf32-mips.c. */
4153 static const struct ecoff_debug_swap
4154 elf64_alpha_ecoff_debug_swap =
4156 /* Symbol table magic number. */
4158 /* Alignment of debugging information. E.g., 4. */
4160 /* Sizes of external symbolic information. */
4161 sizeof (struct hdr_ext),
4162 sizeof (struct dnr_ext),
4163 sizeof (struct pdr_ext),
4164 sizeof (struct sym_ext),
4165 sizeof (struct opt_ext),
4166 sizeof (struct fdr_ext),
4167 sizeof (struct rfd_ext),
4168 sizeof (struct ext_ext),
4169 /* Functions to swap in external symbolic data. */
4178 _bfd_ecoff_swap_tir_in,
4179 _bfd_ecoff_swap_rndx_in,
4180 /* Functions to swap out external symbolic data. */
4189 _bfd_ecoff_swap_tir_out,
4190 _bfd_ecoff_swap_rndx_out,
4191 /* Function to read in symbolic data. */
4192 elf64_alpha_read_ecoff_info
4195 /* Use a non-standard hash bucket size of 8. */
4197 const struct elf_size_info alpha_elf_size_info =
4199 sizeof (Elf64_External_Ehdr),
4200 sizeof (Elf64_External_Phdr),
4201 sizeof (Elf64_External_Shdr),
4202 sizeof (Elf64_External_Rel),
4203 sizeof (Elf64_External_Rela),
4204 sizeof (Elf64_External_Sym),
4205 sizeof (Elf64_External_Dyn),
4206 sizeof (Elf_External_Note),
4210 ELFCLASS64, EV_CURRENT,
4211 bfd_elf64_write_out_phdrs,
4212 bfd_elf64_write_shdrs_and_ehdr,
4213 bfd_elf64_write_relocs,
4214 bfd_elf64_swap_symbol_out,
4215 bfd_elf64_slurp_reloc_table,
4216 bfd_elf64_slurp_symbol_table,
4217 bfd_elf64_swap_dyn_in,
4218 bfd_elf64_swap_dyn_out,
4225 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4226 #define TARGET_LITTLE_NAME "elf64-alpha"
4227 #define ELF_ARCH bfd_arch_alpha
4228 #define ELF_MACHINE_CODE EM_ALPHA
4229 #define ELF_MAXPAGESIZE 0x10000
4231 #define bfd_elf64_bfd_link_hash_table_create \
4232 elf64_alpha_bfd_link_hash_table_create
4234 #define bfd_elf64_bfd_reloc_type_lookup \
4235 elf64_alpha_bfd_reloc_type_lookup
4236 #define elf_info_to_howto \
4237 elf64_alpha_info_to_howto
4239 #define bfd_elf64_mkobject \
4240 elf64_alpha_mkobject
4241 #define elf_backend_object_p \
4242 elf64_alpha_object_p
4244 #define elf_backend_section_from_shdr \
4245 elf64_alpha_section_from_shdr
4246 #define elf_backend_section_flags \
4247 elf64_alpha_section_flags
4248 #define elf_backend_fake_sections \
4249 elf64_alpha_fake_sections
4251 #define bfd_elf64_bfd_is_local_label_name \
4252 elf64_alpha_is_local_label_name
4253 #define bfd_elf64_find_nearest_line \
4254 elf64_alpha_find_nearest_line
4255 #define bfd_elf64_bfd_relax_section \
4256 elf64_alpha_relax_section
4258 #define elf_backend_add_symbol_hook \
4259 elf64_alpha_add_symbol_hook
4260 #define elf_backend_check_relocs \
4261 elf64_alpha_check_relocs
4262 #define elf_backend_create_dynamic_sections \
4263 elf64_alpha_create_dynamic_sections
4264 #define elf_backend_adjust_dynamic_symbol \
4265 elf64_alpha_adjust_dynamic_symbol
4266 #define elf_backend_always_size_sections \
4267 elf64_alpha_always_size_sections
4268 #define elf_backend_size_dynamic_sections \
4269 elf64_alpha_size_dynamic_sections
4270 #define elf_backend_relocate_section \
4271 elf64_alpha_relocate_section
4272 #define elf_backend_finish_dynamic_symbol \
4273 elf64_alpha_finish_dynamic_symbol
4274 #define elf_backend_finish_dynamic_sections \
4275 elf64_alpha_finish_dynamic_sections
4276 #define bfd_elf64_bfd_final_link \
4277 elf64_alpha_final_link
4278 #define elf_backend_reloc_type_class \
4279 elf64_alpha_reloc_type_class
4281 #define elf_backend_ecoff_debug_swap \
4282 &elf64_alpha_ecoff_debug_swap
4284 #define elf_backend_size_info \
4287 /* A few constants that determine how the .plt section is set up. */
4288 #define elf_backend_want_got_plt 0
4289 #define elf_backend_plt_readonly 0
4290 #define elf_backend_want_plt_sym 1
4291 #define elf_backend_got_header_size 0
4292 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4294 #include "elf64-target.h"