1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
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 /* $FreeBSD: src/contrib/binutils/bfd/elf64-alpha.c,v 1.3.2.5 2002/09/01 23:43:38 obrien Exp $ */
24 /* We need a published ABI spec for this. Until one comes out, don't
25 assume this'll remain unchanged forever. */
32 #include "elf/alpha.h"
36 #define NO_COFF_RELOCS
37 #define NO_COFF_SYMBOLS
38 #define NO_COFF_LINENOS
40 /* Get the ECOFF swapping routines. Needed for the debug information. */
41 #include "coff/internal.h"
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/alpha.h"
50 #include "ecoffswap.h"
52 static int alpha_elf_dynamic_symbol_p
53 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
54 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
55 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
56 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
59 static bfd_reloc_status_type elf64_alpha_reloc_nil
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61 static bfd_reloc_status_type elf64_alpha_reloc_bad
62 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
63 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
64 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
65 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
66 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
68 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
69 PARAMS((bfd *, bfd_reloc_code_real_type));
70 static void elf64_alpha_info_to_howto
71 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
73 static boolean elf64_alpha_mkobject
75 static boolean elf64_alpha_object_p
77 static boolean elf64_alpha_section_from_shdr
78 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
79 static boolean elf64_alpha_section_flags
80 PARAMS((flagword *, Elf64_Internal_Shdr *));
81 static boolean elf64_alpha_fake_sections
82 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
83 static boolean elf64_alpha_create_got_section
84 PARAMS((bfd *, struct bfd_link_info *));
85 static boolean elf64_alpha_create_dynamic_sections
86 PARAMS((bfd *, struct bfd_link_info *));
88 static boolean elf64_alpha_read_ecoff_info
89 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
90 static boolean elf64_alpha_is_local_label_name
91 PARAMS((bfd *, const char *));
92 static boolean elf64_alpha_find_nearest_line
93 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
94 const char **, unsigned int *));
96 #if defined(__STDC__) || defined(ALMOST_STDC)
97 struct alpha_elf_link_hash_entry;
100 static boolean elf64_alpha_output_extsym
101 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
103 static boolean elf64_alpha_can_merge_gots
104 PARAMS((bfd *, bfd *));
105 static void elf64_alpha_merge_gots
106 PARAMS((bfd *, bfd *));
107 static boolean elf64_alpha_calc_got_offsets_for_symbol
108 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
109 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
110 static boolean elf64_alpha_size_got_sections
111 PARAMS ((bfd *, struct bfd_link_info *));
112 static boolean elf64_alpha_always_size_sections
113 PARAMS ((bfd *, struct bfd_link_info *));
114 static boolean elf64_alpha_calc_dynrel_sizes
115 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
116 static boolean elf64_alpha_add_symbol_hook
117 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
118 const char **, flagword *, asection **, bfd_vma *));
119 static boolean elf64_alpha_check_relocs
120 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
121 const Elf_Internal_Rela *));
122 static boolean elf64_alpha_adjust_dynamic_symbol
123 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
124 static boolean elf64_alpha_size_dynamic_sections
125 PARAMS((bfd *, struct bfd_link_info *));
126 static boolean elf64_alpha_relocate_section
127 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
128 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
129 static boolean elf64_alpha_finish_dynamic_symbol
130 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
131 Elf_Internal_Sym *));
132 static boolean elf64_alpha_finish_dynamic_sections
133 PARAMS((bfd *, struct bfd_link_info *));
134 static boolean elf64_alpha_final_link
135 PARAMS((bfd *, struct bfd_link_info *));
136 static boolean elf64_alpha_merge_ind_symbols
137 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
138 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
139 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
140 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
141 PARAMS ((const Elf_Internal_Rela *));
143 struct alpha_elf_link_hash_entry
145 struct elf_link_hash_entry root;
147 /* External symbol information. */
150 /* Cumulative flags for all the .got entries. */
153 /* Contexts (LITUSE) in which a literal was referenced. */
154 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
155 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
156 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
157 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
159 /* Used to implement multiple .got subsections. */
160 struct alpha_elf_got_entry
162 struct alpha_elf_got_entry *next;
164 /* which .got subsection? */
167 /* the addend in effect for this entry. */
170 /* the .got offset for this entry. */
175 /* Additional flags. */
176 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
177 #define ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED 0x20
182 /* used to count non-got, non-plt relocations for delayed sizing
183 of relocation sections. */
184 struct alpha_elf_reloc_entry
186 struct alpha_elf_reloc_entry *next;
188 /* which .reloc section? */
191 /* what kind of relocation? */
194 /* is this against read-only section? */
195 unsigned int reltext : 1;
197 /* how many did we find? */
202 /* Alpha ELF linker hash table. */
204 struct alpha_elf_link_hash_table
206 struct elf_link_hash_table root;
208 /* The head of a list of .got subsections linked through
209 alpha_elf_tdata(abfd)->got_link_next. */
213 /* Look up an entry in a Alpha ELF linker hash table. */
215 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
216 ((struct alpha_elf_link_hash_entry *) \
217 elf_link_hash_lookup (&(table)->root, (string), (create), \
220 /* Traverse a Alpha ELF linker hash table. */
222 #define alpha_elf_link_hash_traverse(table, func, info) \
223 (elf_link_hash_traverse \
225 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
228 /* Get the Alpha ELF linker hash table from a link_info structure. */
230 #define alpha_elf_hash_table(p) \
231 ((struct alpha_elf_link_hash_table *) ((p)->hash))
233 /* Get the object's symbols as our own entry type. */
235 #define alpha_elf_sym_hashes(abfd) \
236 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
238 /* Should we do dynamic things to this symbol? */
241 alpha_elf_dynamic_symbol_p (h, info)
242 struct elf_link_hash_entry *h;
243 struct bfd_link_info *info;
248 while (h->root.type == bfd_link_hash_indirect
249 || h->root.type == bfd_link_hash_warning)
250 h = (struct elf_link_hash_entry *) h->root.u.i.link;
252 if (h->dynindx == -1)
255 if (h->root.type == bfd_link_hash_undefweak
256 || h->root.type == bfd_link_hash_defweak)
259 switch (ELF_ST_VISIBILITY (h->other))
267 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
272 if ((info->shared && !info->symbolic)
273 || ((h->elf_link_hash_flags
274 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
275 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
281 /* Create an entry in a Alpha ELF linker hash table. */
283 static struct bfd_hash_entry *
284 elf64_alpha_link_hash_newfunc (entry, table, string)
285 struct bfd_hash_entry *entry;
286 struct bfd_hash_table *table;
289 struct alpha_elf_link_hash_entry *ret =
290 (struct alpha_elf_link_hash_entry *) entry;
292 /* Allocate the structure if it has not already been allocated by a
294 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
295 ret = ((struct alpha_elf_link_hash_entry *)
296 bfd_hash_allocate (table,
297 sizeof (struct alpha_elf_link_hash_entry)));
298 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
299 return (struct bfd_hash_entry *) ret;
301 /* Call the allocation method of the superclass. */
302 ret = ((struct alpha_elf_link_hash_entry *)
303 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
305 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
307 /* Set local fields. */
308 memset (&ret->esym, 0, sizeof (EXTR));
309 /* We use -2 as a marker to indicate that the information has
310 not been set. -1 means there is no associated ifd. */
313 ret->got_entries = NULL;
314 ret->reloc_entries = NULL;
317 return (struct bfd_hash_entry *) ret;
320 /* Create a Alpha ELF linker hash table. */
322 static struct bfd_link_hash_table *
323 elf64_alpha_bfd_link_hash_table_create (abfd)
326 struct alpha_elf_link_hash_table *ret;
327 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
329 ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
330 if (ret == (struct alpha_elf_link_hash_table *) NULL)
333 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
334 elf64_alpha_link_hash_newfunc))
336 bfd_release (abfd, ret);
340 return &ret->root.root;
343 /* We have some private fields hanging off of the elf_tdata structure. */
345 struct alpha_elf_obj_tdata
347 struct elf_obj_tdata root;
349 /* For every input file, these are the got entries for that object's
351 struct alpha_elf_got_entry ** local_got_entries;
353 /* For every input file, this is the object that owns the got that
354 this input file uses. */
357 /* For every got, this is a linked list through the objects using this got */
358 bfd *in_got_link_next;
360 /* For every got, this is a link to the next got subsegment. */
363 /* For every got, this is the section. */
366 /* For every got, this is it's total number of *entries*. */
367 int total_got_entries;
369 /* For every got, this is the sum of the number of *entries* required
370 to hold all of the member object's local got. */
371 int n_local_got_entries;
374 #define alpha_elf_tdata(abfd) \
375 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
378 elf64_alpha_mkobject (abfd)
381 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
382 abfd->tdata.any = bfd_zalloc (abfd, amt);
383 if (abfd->tdata.any == NULL)
389 elf64_alpha_object_p (abfd)
392 /* Allocate our special target data. */
393 struct alpha_elf_obj_tdata *new_tdata;
394 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
395 new_tdata = bfd_zalloc (abfd, amt);
396 if (new_tdata == NULL)
398 new_tdata->root = *abfd->tdata.elf_obj_data;
399 abfd->tdata.any = new_tdata;
401 /* Set the right machine number for an Alpha ELF file. */
402 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
405 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
406 from smaller values. Start with zero, widen, *then* decrement. */
407 #define MINUS_ONE (((bfd_vma)0) - 1)
409 #define SKIP_HOWTO(N) \
410 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
412 static reloc_howto_type elf64_alpha_howto_table[] =
414 HOWTO (R_ALPHA_NONE, /* type */
416 0, /* size (0 = byte, 1 = short, 2 = long) */
418 true, /* pc_relative */
420 complain_overflow_dont, /* complain_on_overflow */
421 elf64_alpha_reloc_nil, /* special_function */
423 false, /* partial_inplace */
426 true), /* pcrel_offset */
428 /* A 32 bit reference to a symbol. */
429 HOWTO (R_ALPHA_REFLONG, /* type */
431 2, /* size (0 = byte, 1 = short, 2 = long) */
433 false, /* pc_relative */
435 complain_overflow_bitfield, /* complain_on_overflow */
436 0, /* special_function */
437 "REFLONG", /* name */
438 false, /* partial_inplace */
439 0xffffffff, /* src_mask */
440 0xffffffff, /* dst_mask */
441 false), /* pcrel_offset */
443 /* A 64 bit reference to a symbol. */
444 HOWTO (R_ALPHA_REFQUAD, /* type */
446 4, /* size (0 = byte, 1 = short, 2 = long) */
448 false, /* pc_relative */
450 complain_overflow_bitfield, /* complain_on_overflow */
451 0, /* special_function */
452 "REFQUAD", /* name */
453 false, /* partial_inplace */
454 MINUS_ONE, /* src_mask */
455 MINUS_ONE, /* dst_mask */
456 false), /* pcrel_offset */
458 /* A 32 bit GP relative offset. This is just like REFLONG except
459 that when the value is used the value of the gp register will be
461 HOWTO (R_ALPHA_GPREL32, /* type */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
465 false, /* pc_relative */
467 complain_overflow_bitfield, /* complain_on_overflow */
468 0, /* special_function */
469 "GPREL32", /* name */
470 false, /* partial_inplace */
471 0xffffffff, /* src_mask */
472 0xffffffff, /* dst_mask */
473 false), /* pcrel_offset */
475 /* Used for an instruction that refers to memory off the GP register. */
476 HOWTO (R_ALPHA_LITERAL, /* type */
478 1, /* size (0 = byte, 1 = short, 2 = long) */
480 false, /* pc_relative */
482 complain_overflow_signed, /* complain_on_overflow */
483 0, /* special_function */
484 "ELF_LITERAL", /* name */
485 false, /* partial_inplace */
486 0xffff, /* src_mask */
487 0xffff, /* dst_mask */
488 false), /* pcrel_offset */
490 /* This reloc only appears immediately following an ELF_LITERAL reloc.
491 It identifies a use of the literal. The symbol index is special:
492 1 means the literal address is in the base register of a memory
493 format instruction; 2 means the literal address is in the byte
494 offset register of a byte-manipulation instruction; 3 means the
495 literal address is in the target register of a jsr instruction.
496 This does not actually do any relocation. */
497 HOWTO (R_ALPHA_LITUSE, /* type */
499 1, /* size (0 = byte, 1 = short, 2 = long) */
501 false, /* pc_relative */
503 complain_overflow_dont, /* complain_on_overflow */
504 elf64_alpha_reloc_nil, /* special_function */
506 false, /* partial_inplace */
509 false), /* pcrel_offset */
511 /* Load the gp register. This is always used for a ldah instruction
512 which loads the upper 16 bits of the gp register. The symbol
513 index of the GPDISP instruction is an offset in bytes to the lda
514 instruction that loads the lower 16 bits. The value to use for
515 the relocation is the difference between the GP value and the
516 current location; the load will always be done against a register
517 holding the current address.
519 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
520 any offset is present in the instructions, it is an offset from
521 the register to the ldah instruction. This lets us avoid any
522 stupid hackery like inventing a gp value to do partial relocation
523 against. Also unlike ECOFF, we do the whole relocation off of
524 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
525 space consuming bit, that, since all the information was present
526 in the GPDISP_HI16 reloc. */
527 HOWTO (R_ALPHA_GPDISP, /* type */
529 2, /* size (0 = byte, 1 = short, 2 = long) */
531 false, /* pc_relative */
533 complain_overflow_dont, /* complain_on_overflow */
534 elf64_alpha_reloc_gpdisp, /* special_function */
536 false, /* partial_inplace */
537 0xffff, /* src_mask */
538 0xffff, /* dst_mask */
539 true), /* pcrel_offset */
541 /* A 21 bit branch. */
542 HOWTO (R_ALPHA_BRADDR, /* type */
544 2, /* size (0 = byte, 1 = short, 2 = long) */
546 true, /* pc_relative */
548 complain_overflow_signed, /* complain_on_overflow */
549 0, /* special_function */
551 false, /* partial_inplace */
552 0x1fffff, /* src_mask */
553 0x1fffff, /* dst_mask */
554 true), /* pcrel_offset */
556 /* A hint for a jump to a register. */
557 HOWTO (R_ALPHA_HINT, /* type */
559 1, /* size (0 = byte, 1 = short, 2 = long) */
561 true, /* pc_relative */
563 complain_overflow_dont, /* complain_on_overflow */
564 0, /* special_function */
566 false, /* partial_inplace */
567 0x3fff, /* src_mask */
568 0x3fff, /* dst_mask */
569 true), /* pcrel_offset */
571 /* 16 bit PC relative offset. */
572 HOWTO (R_ALPHA_SREL16, /* type */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
576 true, /* pc_relative */
578 complain_overflow_signed, /* complain_on_overflow */
579 0, /* special_function */
581 false, /* partial_inplace */
582 0xffff, /* src_mask */
583 0xffff, /* dst_mask */
584 true), /* pcrel_offset */
586 /* 32 bit PC relative offset. */
587 HOWTO (R_ALPHA_SREL32, /* type */
589 2, /* size (0 = byte, 1 = short, 2 = long) */
591 true, /* pc_relative */
593 complain_overflow_signed, /* complain_on_overflow */
594 0, /* special_function */
596 false, /* partial_inplace */
597 0xffffffff, /* src_mask */
598 0xffffffff, /* dst_mask */
599 true), /* pcrel_offset */
601 /* A 64 bit PC relative offset. */
602 HOWTO (R_ALPHA_SREL64, /* type */
604 4, /* size (0 = byte, 1 = short, 2 = long) */
606 true, /* pc_relative */
608 complain_overflow_signed, /* complain_on_overflow */
609 0, /* special_function */
611 false, /* partial_inplace */
612 MINUS_ONE, /* src_mask */
613 MINUS_ONE, /* dst_mask */
614 true), /* pcrel_offset */
616 /* Skip 12 - 16; deprecated ECOFF relocs. */
623 /* The high 16 bits of the displacement from GP to the target. */
624 HOWTO (R_ALPHA_GPRELHIGH,
626 1, /* size (0 = byte, 1 = short, 2 = long) */
628 false, /* pc_relative */
630 complain_overflow_signed, /* complain_on_overflow */
631 0, /* special_function */
632 "GPRELHIGH", /* name */
633 false, /* partial_inplace */
634 0xffff, /* src_mask */
635 0xffff, /* dst_mask */
636 false), /* pcrel_offset */
638 /* The low 16 bits of the displacement from GP to the target. */
639 HOWTO (R_ALPHA_GPRELLOW,
641 1, /* size (0 = byte, 1 = short, 2 = long) */
643 false, /* pc_relative */
645 complain_overflow_dont, /* complain_on_overflow */
646 0, /* special_function */
647 "GPRELLOW", /* name */
648 false, /* partial_inplace */
649 0xffff, /* src_mask */
650 0xffff, /* dst_mask */
651 false), /* pcrel_offset */
653 /* A 16-bit displacement from the GP to the target. */
654 HOWTO (R_ALPHA_GPREL16,
656 1, /* size (0 = byte, 1 = short, 2 = long) */
658 false, /* pc_relative */
660 complain_overflow_signed, /* complain_on_overflow */
661 0, /* special_function */
662 "GPREL16", /* name */
663 false, /* partial_inplace */
664 0xffff, /* src_mask */
665 0xffff, /* dst_mask */
666 false), /* pcrel_offset */
668 /* Skip 20 - 23; deprecated ECOFF relocs. */
674 /* Misc ELF relocations. */
676 /* A dynamic relocation to copy the target into our .dynbss section. */
677 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
678 is present because every other ELF has one, but should not be used
679 because .dynbss is an ugly thing. */
686 complain_overflow_dont,
687 bfd_elf_generic_reloc,
694 /* A dynamic relocation for a .got entry. */
695 HOWTO (R_ALPHA_GLOB_DAT,
701 complain_overflow_dont,
702 bfd_elf_generic_reloc,
709 /* A dynamic relocation for a .plt entry. */
710 HOWTO (R_ALPHA_JMP_SLOT,
716 complain_overflow_dont,
717 bfd_elf_generic_reloc,
724 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
725 HOWTO (R_ALPHA_RELATIVE,
731 complain_overflow_dont,
732 bfd_elf_generic_reloc,
739 /* A 21 bit branch that adjusts for gp loads. */
740 HOWTO (R_ALPHA_BRSGP, /* type */
742 2, /* size (0 = byte, 1 = short, 2 = long) */
744 true, /* pc_relative */
746 complain_overflow_signed, /* complain_on_overflow */
747 0, /* special_function */
749 false, /* partial_inplace */
750 0x1fffff, /* src_mask */
751 0x1fffff, /* dst_mask */
752 true), /* pcrel_offset */
755 /* A relocation function which doesn't do anything. */
757 static bfd_reloc_status_type
758 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
759 bfd *abfd ATTRIBUTE_UNUSED;
761 asymbol *sym ATTRIBUTE_UNUSED;
762 PTR data ATTRIBUTE_UNUSED;
765 char **error_message ATTRIBUTE_UNUSED;
768 reloc->address += sec->output_offset;
772 /* A relocation function used for an unsupported reloc. */
774 static bfd_reloc_status_type
775 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
776 bfd *abfd ATTRIBUTE_UNUSED;
778 asymbol *sym ATTRIBUTE_UNUSED;
779 PTR data ATTRIBUTE_UNUSED;
782 char **error_message ATTRIBUTE_UNUSED;
785 reloc->address += sec->output_offset;
786 return bfd_reloc_notsupported;
789 /* Do the work of the GPDISP relocation. */
791 static bfd_reloc_status_type
792 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
798 bfd_reloc_status_type ret = bfd_reloc_ok;
800 unsigned long i_ldah, i_lda;
802 i_ldah = bfd_get_32 (abfd, p_ldah);
803 i_lda = bfd_get_32 (abfd, p_lda);
805 /* Complain if the instructions are not correct. */
806 if (((i_ldah >> 26) & 0x3f) != 0x09
807 || ((i_lda >> 26) & 0x3f) != 0x08)
808 ret = bfd_reloc_dangerous;
810 /* Extract the user-supplied offset, mirroring the sign extensions
811 that the instructions perform. */
812 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
813 addend = (addend ^ 0x80008000) - 0x80008000;
817 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
818 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
819 ret = bfd_reloc_overflow;
821 /* compensate for the sign extension again. */
822 i_ldah = ((i_ldah & 0xffff0000)
823 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
824 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
826 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
827 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
832 /* The special function for the GPDISP reloc. */
834 static bfd_reloc_status_type
835 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
838 arelent *reloc_entry;
839 asymbol *sym ATTRIBUTE_UNUSED;
841 asection *input_section;
845 bfd_reloc_status_type ret;
846 bfd_vma gp, relocation;
847 bfd_byte *p_ldah, *p_lda;
849 /* Don't do anything if we're not doing a final link. */
852 reloc_entry->address += input_section->output_offset;
856 if (reloc_entry->address > input_section->_cooked_size ||
857 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
858 return bfd_reloc_outofrange;
860 /* The gp used in the portion of the output object to which this
861 input object belongs is cached on the input bfd. */
862 gp = _bfd_get_gp_value (abfd);
864 relocation = (input_section->output_section->vma
865 + input_section->output_offset
866 + reloc_entry->address);
868 p_ldah = (bfd_byte *) data + reloc_entry->address;
869 p_lda = p_ldah + reloc_entry->addend;
871 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
873 /* Complain if the instructions are not correct. */
874 if (ret == bfd_reloc_dangerous)
875 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
880 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
884 bfd_reloc_code_real_type bfd_reloc_val;
888 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
890 {BFD_RELOC_NONE, R_ALPHA_NONE},
891 {BFD_RELOC_32, R_ALPHA_REFLONG},
892 {BFD_RELOC_64, R_ALPHA_REFQUAD},
893 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
894 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
895 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
896 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
897 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
898 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
899 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
900 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
901 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
902 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
903 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
904 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
905 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
906 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
909 /* Given a BFD reloc type, return a HOWTO structure. */
911 static reloc_howto_type *
912 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
913 bfd *abfd ATTRIBUTE_UNUSED;
914 bfd_reloc_code_real_type code;
916 const struct elf_reloc_map *i, *e;
917 i = e = elf64_alpha_reloc_map;
918 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
921 if (i->bfd_reloc_val == code)
922 return &elf64_alpha_howto_table[i->elf_reloc_val];
927 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
930 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
931 bfd *abfd ATTRIBUTE_UNUSED;
933 Elf64_Internal_Rela *dst;
937 r_type = ELF64_R_TYPE(dst->r_info);
938 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
939 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
942 /* These functions do relaxation for Alpha ELF.
944 Currently I'm only handling what I can do with existing compiler
945 and assembler support, which means no instructions are removed,
946 though some may be nopped. At this time GCC does not emit enough
947 information to do all of the relaxing that is possible. It will
948 take some not small amount of work for that to happen.
950 There are a couple of interesting papers that I once read on this
951 subject, that I cannot find references to at the moment, that
952 related to Alpha in particular. They are by David Wall, then of
957 #define INSN_JSR 0x68004000
958 #define INSN_JSR_MASK 0xfc00c000
962 #define INSN_UNOP 0x2ffe0000
964 struct alpha_relax_info
969 Elf_Internal_Rela *relocs, *relend;
970 struct bfd_link_info *link_info;
971 boolean changed_contents;
972 boolean changed_relocs;
976 struct alpha_elf_link_hash_entry *h;
977 struct alpha_elf_got_entry *gotent;
981 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
982 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
983 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
985 static boolean elf64_alpha_relax_without_lituse
986 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
987 Elf_Internal_Rela *irel));
989 static bfd_vma elf64_alpha_relax_opt_call
990 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
992 static boolean elf64_alpha_relax_section
993 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
996 static Elf_Internal_Rela *
997 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
998 Elf_Internal_Rela *rel, *relend;
1002 while (rel < relend)
1004 if (rel->r_offset == offset
1005 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
1012 static Elf_Internal_Rela *
1013 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1014 struct alpha_relax_info *info;
1016 Elf_Internal_Rela *irel, *irelend;
1018 Elf_Internal_Rela *urel;
1019 int flags, count, i;
1020 bfd_signed_vma disp;
1023 boolean lit_reused = false;
1024 boolean all_optimized = true;
1025 unsigned int lit_insn;
1027 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1028 if (lit_insn >> 26 != OP_LDQ)
1030 ((*_bfd_error_handler)
1031 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1032 bfd_archive_filename (info->abfd), info->sec->name,
1033 (unsigned long) irel->r_offset));
1037 /* Summarize how this particular LITERAL is used. */
1038 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1040 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1042 if (urel->r_addend <= 3)
1043 flags |= 1 << urel->r_addend;
1046 /* A little preparation for the loop... */
1047 disp = symval - info->gp;
1049 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1053 bfd_signed_vma xdisp;
1055 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1057 switch (urel->r_addend)
1059 default: /* 0 = ADDRESS FORMAT */
1060 /* This type is really just a placeholder to note that all
1061 uses cannot be optimized, but to still allow some. */
1062 all_optimized = false;
1065 case 1: /* MEM FORMAT */
1066 /* We can always optimize 16-bit displacements. */
1068 /* Extract the displacement from the instruction, sign-extending
1069 it if necessary, then test whether it is within 16 or 32 bits
1070 displacement from GP. */
1071 insn_disp = insn & 0x0000ffff;
1072 if (insn_disp & 0x00008000)
1073 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1075 xdisp = disp + insn_disp;
1076 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1077 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1081 /* Take the op code and dest from this insn, take the base
1082 register from the literal insn. Leave the offset alone. */
1083 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1084 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1086 urel->r_addend = irel->r_addend;
1087 info->changed_relocs = true;
1089 bfd_put_32 (info->abfd, (bfd_vma) insn,
1090 info->contents + urel->r_offset);
1091 info->changed_contents = true;
1094 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1095 else if (fits32 && !(flags & ~6))
1097 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1099 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1101 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1102 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1103 info->contents + irel->r_offset);
1105 info->changed_contents = true;
1107 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1109 urel->r_addend = irel->r_addend;
1110 info->changed_relocs = true;
1113 all_optimized = false;
1116 case 2: /* BYTE OFFSET FORMAT */
1117 /* We can always optimize byte instructions. */
1119 /* FIXME: sanity check the insn for byte op. Check that the
1120 literal dest reg is indeed Rb in the byte insn. */
1122 insn &= ~ (unsigned) 0x001ff000;
1123 insn |= ((symval & 7) << 13) | 0x1000;
1125 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1127 info->changed_relocs = true;
1129 bfd_put_32 (info->abfd, (bfd_vma) insn,
1130 info->contents + urel->r_offset);
1131 info->changed_contents = true;
1134 case 3: /* CALL FORMAT */
1136 /* If not zero, place to jump without needing pv. */
1137 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1138 bfd_vma org = (info->sec->output_section->vma
1139 + info->sec->output_offset
1140 + urel->r_offset + 4);
1141 bfd_signed_vma odisp;
1143 odisp = (optdest ? optdest : symval) - org;
1144 if (odisp >= -0x400000 && odisp < 0x400000)
1146 Elf_Internal_Rela *xrel;
1148 /* Preserve branch prediction call stack when possible. */
1149 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1150 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1152 insn = (OP_BR << 26) | (insn & 0x03e00000);
1154 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1156 urel->r_addend = irel->r_addend;
1159 urel->r_addend += optdest - symval;
1161 all_optimized = false;
1163 bfd_put_32 (info->abfd, (bfd_vma) insn,
1164 info->contents + urel->r_offset);
1166 /* Kill any HINT reloc that might exist for this insn. */
1167 xrel = (elf64_alpha_find_reloc_at_ofs
1168 (info->relocs, info->relend, urel->r_offset,
1171 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1173 info->changed_contents = true;
1174 info->changed_relocs = true;
1177 all_optimized = false;
1179 /* Even if the target is not in range for a direct branch,
1180 if we share a GP, we can eliminate the gp reload. */
1183 Elf_Internal_Rela *gpdisp
1184 = (elf64_alpha_find_reloc_at_ofs
1185 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1188 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1189 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1190 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1191 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1193 /* Verify that the instruction is "ldah $29,0($26)".
1194 Consider a function that ends in a noreturn call,
1195 and that the next function begins with an ldgp,
1196 and that by accident there is no padding between.
1197 In that case the insn would use $27 as the base. */
1198 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1200 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1201 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1203 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1204 info->changed_contents = true;
1205 info->changed_relocs = true;
1214 /* If all cases were optimized, we can reduce the use count on this
1215 got entry by one, possibly eliminating it. */
1218 info->gotent->use_count -= 1;
1219 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1221 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1223 /* If the literal instruction is no longer needed (it may have been
1224 reused. We can eliminate it.
1225 ??? For now, I don't want to deal with compacting the section,
1226 so just nop it out. */
1229 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1230 info->changed_relocs = true;
1232 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1233 info->contents + irel->r_offset);
1234 info->changed_contents = true;
1238 return irel + count;
1242 elf64_alpha_relax_opt_call (info, symval)
1243 struct alpha_relax_info *info;
1246 /* If the function has the same gp, and we can identify that the
1247 function does not use its function pointer, we can eliminate the
1250 /* If the symbol is marked NOPV, we are being told the function never
1251 needs its procedure value. */
1252 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1255 /* If the symbol is marked STD_GP, we are being told the function does
1256 a normal ldgp in the first two words. */
1257 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1260 /* Otherwise, we may be able to identify a GP load in the first two
1261 words, which we can then skip. */
1264 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1267 /* Load the relocations from the section that the target symbol is in. */
1268 if (info->sec == info->tsec)
1270 tsec_relocs = info->relocs;
1271 tsec_relend = info->relend;
1276 tsec_relocs = (_bfd_elf64_link_read_relocs
1277 (info->abfd, info->tsec, (PTR) NULL,
1278 (Elf_Internal_Rela *) NULL,
1279 info->link_info->keep_memory));
1280 if (tsec_relocs == NULL)
1282 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1283 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1286 /* Recover the symbol's offset within the section. */
1287 ofs = (symval - info->tsec->output_section->vma
1288 - info->tsec->output_offset);
1290 /* Look for a GPDISP reloc. */
1291 gpdisp = (elf64_alpha_find_reloc_at_ofs
1292 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1294 if (!gpdisp || gpdisp->r_addend != 4)
1304 /* We've now determined that we can skip an initial gp load. Verify
1305 that the call and the target use the same gp. */
1306 if (info->link_info->hash->creator != info->tsec->owner->xvec
1307 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1314 elf64_alpha_relax_without_lituse (info, symval, irel)
1315 struct alpha_relax_info *info;
1317 Elf_Internal_Rela *irel;
1320 bfd_signed_vma disp;
1322 /* Get the instruction. */
1323 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1325 if (insn >> 26 != OP_LDQ)
1327 ((*_bfd_error_handler)
1328 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1329 bfd_archive_filename (info->abfd), info->sec->name,
1330 (unsigned long) irel->r_offset));
1334 /* So we aren't told much. Do what we can with the address load and
1335 fake the rest. All of the optimizations here require that the
1336 offset from the GP fit in 16 bits. */
1338 disp = symval - info->gp;
1339 if (disp < -0x8000 || disp >= 0x8000)
1342 /* On the LITERAL instruction itself, consider exchanging
1343 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1345 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1346 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1347 info->changed_contents = true;
1349 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1350 info->changed_relocs = true;
1352 /* Reduce the use count on this got entry by one, possibly
1354 info->gotent->use_count -= 1;
1355 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1357 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1359 /* ??? Search forward through this basic block looking for insns
1360 that use the target register. Stop after an insn modifying the
1361 register is seen, or after a branch or call.
1363 Any such memory load insn may be substituted by a load directly
1364 off the GP. This allows the memory load insn to be issued before
1365 the calculated GP register would otherwise be ready.
1367 Any such jsr insn can be replaced by a bsr if it is in range.
1369 This would mean that we'd have to _add_ relocations, the pain of
1370 which gives one pause. */
1376 elf64_alpha_relax_section (abfd, sec, link_info, again)
1379 struct bfd_link_info *link_info;
1382 Elf_Internal_Shdr *symtab_hdr;
1383 Elf_Internal_Shdr *shndx_hdr;
1384 Elf_Internal_Rela *internal_relocs;
1385 Elf_Internal_Rela *free_relocs = NULL;
1386 Elf_Internal_Rela *irel, *irelend;
1387 bfd_byte *free_contents = NULL;
1388 Elf64_External_Sym *extsyms = NULL;
1389 Elf64_External_Sym *free_extsyms = NULL;
1390 Elf_External_Sym_Shndx *shndx_buf = NULL;
1391 struct alpha_elf_got_entry **local_got_entries;
1392 struct alpha_relax_info info;
1394 /* We are not currently changing any sizes, so only one pass. */
1397 if (link_info->relocateable
1398 || (sec->flags & SEC_RELOC) == 0
1399 || sec->reloc_count == 0)
1402 /* If this is the first time we have been called for this section,
1403 initialize the cooked size. */
1404 if (sec->_cooked_size == 0)
1405 sec->_cooked_size = sec->_raw_size;
1407 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1408 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1410 /* Load the relocations for this section. */
1411 internal_relocs = (_bfd_elf64_link_read_relocs
1412 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1413 link_info->keep_memory));
1414 if (internal_relocs == NULL)
1416 if (! link_info->keep_memory)
1417 free_relocs = internal_relocs;
1419 memset(&info, 0, sizeof (info));
1422 info.link_info = link_info;
1423 info.relocs = internal_relocs;
1424 info.relend = irelend = internal_relocs + sec->reloc_count;
1426 /* Find the GP for this object. */
1427 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1430 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1431 info.gp = _bfd_get_gp_value (info.gotobj);
1434 info.gp = (sgot->output_section->vma
1435 + sgot->output_offset
1437 _bfd_set_gp_value (info.gotobj, info.gp);
1441 for (irel = internal_relocs; irel < irelend; irel++)
1444 Elf_Internal_Sym isym;
1445 struct alpha_elf_got_entry *gotent;
1447 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1450 /* Get the section contents. */
1451 if (info.contents == NULL)
1453 if (elf_section_data (sec)->this_hdr.contents != NULL)
1454 info.contents = elf_section_data (sec)->this_hdr.contents;
1457 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1458 if (info.contents == NULL)
1460 free_contents = info.contents;
1462 if (! bfd_get_section_contents (abfd, sec, info.contents,
1463 (file_ptr) 0, sec->_raw_size))
1468 /* Read this BFD's symbols if we haven't done so already. */
1469 if (extsyms == NULL)
1473 if (symtab_hdr->contents != NULL)
1474 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1477 amt = symtab_hdr->sh_info;
1478 amt *= sizeof (Elf64_External_Sym);
1479 extsyms = (Elf64_External_Sym *) bfd_malloc (amt);
1480 if (extsyms == NULL)
1482 free_extsyms = extsyms;
1483 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1484 || bfd_bread ((PTR) extsyms, amt, abfd) != amt)
1488 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1489 if (shndx_hdr->sh_size != 0)
1491 amt = symtab_hdr->sh_info;
1492 amt *= sizeof (Elf_External_Sym_Shndx);
1493 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1494 if (shndx_buf == NULL)
1496 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1497 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1502 /* Get the value of the symbol referred to by the reloc. */
1503 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1505 /* A local symbol. */
1506 Elf64_External_Sym *esym;
1507 Elf_External_Sym_Shndx *shndx;
1509 esym = extsyms + ELF64_R_SYM (irel->r_info);
1510 shndx = shndx_buf + (shndx_buf ? ELF64_R_SYM (irel->r_info) : 0);
1511 bfd_elf64_swap_symbol_in (abfd, esym, shndx, &isym);
1512 if (isym.st_shndx == SHN_UNDEF)
1513 info.tsec = bfd_und_section_ptr;
1514 else if (isym.st_shndx == SHN_ABS)
1515 info.tsec = bfd_abs_section_ptr;
1516 else if (isym.st_shndx == SHN_COMMON)
1517 info.tsec = bfd_com_section_ptr;
1519 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1522 info.other = isym.st_other;
1523 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1524 symval = isym.st_value;
1529 struct alpha_elf_link_hash_entry *h;
1531 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1532 h = alpha_elf_sym_hashes (abfd)[indx];
1533 BFD_ASSERT (h != NULL);
1535 while (h->root.root.type == bfd_link_hash_indirect
1536 || h->root.root.type == bfd_link_hash_warning)
1537 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1539 /* We can't do anthing with undefined or dynamic symbols. */
1540 if (h->root.root.type == bfd_link_hash_undefined
1541 || h->root.root.type == bfd_link_hash_undefweak
1542 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1546 info.tsec = h->root.root.u.def.section;
1547 info.other = h->root.other;
1548 gotent = h->got_entries;
1549 symval = h->root.root.u.def.value;
1552 /* Search for the got entry to be used by this relocation. */
1553 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1554 gotent = gotent->next;
1555 info.gotent = gotent;
1557 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1558 symval += irel->r_addend;
1560 BFD_ASSERT(info.gotent != NULL);
1562 /* If there exist LITUSE relocations immediately following, this
1563 opens up all sorts of interesting optimizations, because we
1564 now know every location that this address load is used. */
1566 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1568 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1574 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1579 if (!elf64_alpha_size_got_sections (abfd, link_info))
1582 if (info.changed_relocs)
1584 elf_section_data (sec)->relocs = internal_relocs;
1586 else if (free_relocs != NULL)
1591 if (info.changed_contents)
1593 elf_section_data (sec)->this_hdr.contents = info.contents;
1595 else if (free_contents != NULL)
1597 if (! link_info->keep_memory)
1598 free (free_contents);
1601 /* Cache the section contents for elf_link_input_bfd. */
1602 elf_section_data (sec)->this_hdr.contents = info.contents;
1606 if (shndx_buf != NULL)
1609 if (free_extsyms != NULL)
1611 if (! link_info->keep_memory)
1612 free (free_extsyms);
1615 /* Cache the symbols for elf_link_input_bfd. */
1616 symtab_hdr->contents = (unsigned char *) extsyms;
1620 *again = info.changed_contents || info.changed_relocs;
1625 if (free_relocs != NULL)
1627 if (free_contents != NULL)
1628 free (free_contents);
1629 if (shndx_buf != NULL)
1631 if (free_extsyms != NULL)
1632 free (free_extsyms);
1637 #define PLT_HEADER_SIZE 32
1638 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1639 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1640 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1641 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
1643 #define PLT_ENTRY_SIZE 12
1644 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1645 #define PLT_ENTRY_WORD2 0
1646 #define PLT_ENTRY_WORD3 0
1648 #define MAX_GOT_ENTRIES (64*1024 / 8)
1650 #ifndef ELF_DYNAMIC_INTERPRETER
1651 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1654 /* Handle an Alpha specific section when reading an object file. This
1655 is called when elfcode.h finds a section with an unknown type.
1656 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1660 elf64_alpha_section_from_shdr (abfd, hdr, name)
1662 Elf64_Internal_Shdr *hdr;
1667 /* There ought to be a place to keep ELF backend specific flags, but
1668 at the moment there isn't one. We just keep track of the
1669 sections by their name, instead. Fortunately, the ABI gives
1670 suggested names for all the MIPS specific sections, so we will
1671 probably get away with this. */
1672 switch (hdr->sh_type)
1674 case SHT_ALPHA_DEBUG:
1675 if (strcmp (name, ".mdebug") != 0)
1682 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1684 newsect = hdr->bfd_section;
1686 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1688 if (! bfd_set_section_flags (abfd, newsect,
1689 (bfd_get_section_flags (abfd, newsect)
1697 /* Convert Alpha specific section flags to bfd internal section flags. */
1700 elf64_alpha_section_flags (flags, hdr)
1702 Elf64_Internal_Shdr *hdr;
1704 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1705 *flags |= SEC_SMALL_DATA;
1710 /* Set the correct type for an Alpha ELF section. We do this by the
1711 section name, which is a hack, but ought to work. */
1714 elf64_alpha_fake_sections (abfd, hdr, sec)
1716 Elf64_Internal_Shdr *hdr;
1719 register const char *name;
1721 name = bfd_get_section_name (abfd, sec);
1723 if (strcmp (name, ".mdebug") == 0)
1725 hdr->sh_type = SHT_ALPHA_DEBUG;
1726 /* In a shared object on Irix 5.3, the .mdebug section has an
1727 entsize of 0. FIXME: Does this matter? */
1728 if ((abfd->flags & DYNAMIC) != 0 )
1729 hdr->sh_entsize = 0;
1731 hdr->sh_entsize = 1;
1733 else if ((sec->flags & SEC_SMALL_DATA)
1734 || strcmp (name, ".sdata") == 0
1735 || strcmp (name, ".sbss") == 0
1736 || strcmp (name, ".lit4") == 0
1737 || strcmp (name, ".lit8") == 0)
1738 hdr->sh_flags |= SHF_ALPHA_GPREL;
1743 /* Hook called by the linker routine which adds symbols from an object
1744 file. We use it to put .comm items in .sbss, and not .bss. */
1747 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1749 struct bfd_link_info *info;
1750 const Elf_Internal_Sym *sym;
1751 const char **namep ATTRIBUTE_UNUSED;
1752 flagword *flagsp ATTRIBUTE_UNUSED;
1756 if (sym->st_shndx == SHN_COMMON
1757 && !info->relocateable
1758 && sym->st_size <= elf_gp_size (abfd))
1760 /* Common symbols less than or equal to -G nn bytes are
1761 automatically put into .sbss. */
1763 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1767 scomm = bfd_make_section (abfd, ".scommon");
1769 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1771 | SEC_LINKER_CREATED)))
1776 *valp = sym->st_size;
1782 /* Create the .got section. */
1785 elf64_alpha_create_got_section(abfd, info)
1787 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1791 if (bfd_get_section_by_name (abfd, ".got"))
1794 s = bfd_make_section (abfd, ".got");
1796 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1799 | SEC_LINKER_CREATED))
1800 || !bfd_set_section_alignment (abfd, s, 3))
1803 alpha_elf_tdata (abfd)->got = s;
1808 /* Create all the dynamic sections. */
1811 elf64_alpha_create_dynamic_sections (abfd, info)
1813 struct bfd_link_info *info;
1816 struct elf_link_hash_entry *h;
1818 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1820 s = bfd_make_section (abfd, ".plt");
1822 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1825 | SEC_LINKER_CREATED
1827 || ! bfd_set_section_alignment (abfd, s, 3))
1830 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1833 if (! (_bfd_generic_link_add_one_symbol
1834 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1835 (bfd_vma) 0, (const char *) NULL, false,
1836 get_elf_backend_data (abfd)->collect,
1837 (struct bfd_link_hash_entry **) &h)))
1839 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1840 h->type = STT_OBJECT;
1843 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1846 s = bfd_make_section (abfd, ".rela.plt");
1848 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1851 | SEC_LINKER_CREATED
1853 || ! bfd_set_section_alignment (abfd, s, 3))
1856 /* We may or may not have created a .got section for this object, but
1857 we definitely havn't done the rest of the work. */
1859 if (!elf64_alpha_create_got_section (abfd, info))
1862 s = bfd_make_section(abfd, ".rela.got");
1864 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1867 | SEC_LINKER_CREATED
1869 || !bfd_set_section_alignment (abfd, s, 3))
1872 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1873 dynobj's .got section. We don't do this in the linker script
1874 because we don't want to define the symbol if we are not creating
1875 a global offset table. */
1877 if (!(_bfd_generic_link_add_one_symbol
1878 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1879 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1880 false, get_elf_backend_data (abfd)->collect,
1881 (struct bfd_link_hash_entry **) &h)))
1883 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1884 h->type = STT_OBJECT;
1887 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1890 elf_hash_table (info)->hgot = h;
1895 /* Read ECOFF debugging information from a .mdebug section into a
1896 ecoff_debug_info structure. */
1899 elf64_alpha_read_ecoff_info (abfd, section, debug)
1902 struct ecoff_debug_info *debug;
1905 const struct ecoff_debug_swap *swap;
1906 char *ext_hdr = NULL;
1908 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1909 memset (debug, 0, sizeof (*debug));
1911 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1912 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1915 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1916 swap->external_hdr_size)
1920 symhdr = &debug->symbolic_header;
1921 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1923 /* The symbolic header contains absolute file offsets and sizes to
1925 #define READ(ptr, offset, count, size, type) \
1926 if (symhdr->count == 0) \
1927 debug->ptr = NULL; \
1930 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1931 debug->ptr = (type) bfd_malloc (amt); \
1932 if (debug->ptr == NULL) \
1933 goto error_return; \
1934 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1935 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1936 goto error_return; \
1939 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1940 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1941 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1942 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1943 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1944 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1946 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1947 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1948 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1949 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1950 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1954 debug->adjust = NULL;
1959 if (ext_hdr != NULL)
1961 if (debug->line != NULL)
1963 if (debug->external_dnr != NULL)
1964 free (debug->external_dnr);
1965 if (debug->external_pdr != NULL)
1966 free (debug->external_pdr);
1967 if (debug->external_sym != NULL)
1968 free (debug->external_sym);
1969 if (debug->external_opt != NULL)
1970 free (debug->external_opt);
1971 if (debug->external_aux != NULL)
1972 free (debug->external_aux);
1973 if (debug->ss != NULL)
1975 if (debug->ssext != NULL)
1976 free (debug->ssext);
1977 if (debug->external_fdr != NULL)
1978 free (debug->external_fdr);
1979 if (debug->external_rfd != NULL)
1980 free (debug->external_rfd);
1981 if (debug->external_ext != NULL)
1982 free (debug->external_ext);
1986 /* Alpha ELF local labels start with '$'. */
1989 elf64_alpha_is_local_label_name (abfd, name)
1990 bfd *abfd ATTRIBUTE_UNUSED;
1993 return name[0] == '$';
1996 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1997 routine in order to handle the ECOFF debugging information. We
1998 still call this mips_elf_find_line because of the slot
1999 find_line_info in elf_obj_tdata is declared that way. */
2001 struct mips_elf_find_line
2003 struct ecoff_debug_info d;
2004 struct ecoff_find_line i;
2008 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2009 functionname_ptr, line_ptr)
2014 const char **filename_ptr;
2015 const char **functionname_ptr;
2016 unsigned int *line_ptr;
2020 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2021 filename_ptr, functionname_ptr,
2023 &elf_tdata (abfd)->dwarf2_find_line_info))
2026 msec = bfd_get_section_by_name (abfd, ".mdebug");
2030 struct mips_elf_find_line *fi;
2031 const struct ecoff_debug_swap * const swap =
2032 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2034 /* If we are called during a link, alpha_elf_final_link may have
2035 cleared the SEC_HAS_CONTENTS field. We force it back on here
2036 if appropriate (which it normally will be). */
2037 origflags = msec->flags;
2038 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2039 msec->flags |= SEC_HAS_CONTENTS;
2041 fi = elf_tdata (abfd)->find_line_info;
2044 bfd_size_type external_fdr_size;
2047 struct fdr *fdr_ptr;
2048 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2050 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2053 msec->flags = origflags;
2057 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2059 msec->flags = origflags;
2063 /* Swap in the FDR information. */
2064 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2065 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2066 if (fi->d.fdr == NULL)
2068 msec->flags = origflags;
2071 external_fdr_size = swap->external_fdr_size;
2072 fdr_ptr = fi->d.fdr;
2073 fraw_src = (char *) fi->d.external_fdr;
2074 fraw_end = (fraw_src
2075 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2076 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2077 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2079 elf_tdata (abfd)->find_line_info = fi;
2081 /* Note that we don't bother to ever free this information.
2082 find_nearest_line is either called all the time, as in
2083 objdump -l, so the information should be saved, or it is
2084 rarely called, as in ld error messages, so the memory
2085 wasted is unimportant. Still, it would probably be a
2086 good idea for free_cached_info to throw it away. */
2089 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2090 &fi->i, filename_ptr, functionname_ptr,
2093 msec->flags = origflags;
2097 msec->flags = origflags;
2100 /* Fall back on the generic ELF find_nearest_line routine. */
2102 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2103 filename_ptr, functionname_ptr,
2107 /* Structure used to pass information to alpha_elf_output_extsym. */
2112 struct bfd_link_info *info;
2113 struct ecoff_debug_info *debug;
2114 const struct ecoff_debug_swap *swap;
2119 elf64_alpha_output_extsym (h, data)
2120 struct alpha_elf_link_hash_entry *h;
2123 struct extsym_info *einfo = (struct extsym_info *) data;
2125 asection *sec, *output_section;
2127 if (h->root.root.type == bfd_link_hash_warning)
2128 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2130 if (h->root.indx == -2)
2132 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2133 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2134 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2135 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2137 else if (einfo->info->strip == strip_all
2138 || (einfo->info->strip == strip_some
2139 && bfd_hash_lookup (einfo->info->keep_hash,
2140 h->root.root.root.string,
2141 false, false) == NULL))
2149 if (h->esym.ifd == -2)
2152 h->esym.cobol_main = 0;
2153 h->esym.weakext = 0;
2154 h->esym.reserved = 0;
2155 h->esym.ifd = ifdNil;
2156 h->esym.asym.value = 0;
2157 h->esym.asym.st = stGlobal;
2159 if (h->root.root.type != bfd_link_hash_defined
2160 && h->root.root.type != bfd_link_hash_defweak)
2161 h->esym.asym.sc = scAbs;
2166 sec = h->root.root.u.def.section;
2167 output_section = sec->output_section;
2169 /* When making a shared library and symbol h is the one from
2170 the another shared library, OUTPUT_SECTION may be null. */
2171 if (output_section == NULL)
2172 h->esym.asym.sc = scUndefined;
2175 name = bfd_section_name (output_section->owner, output_section);
2177 if (strcmp (name, ".text") == 0)
2178 h->esym.asym.sc = scText;
2179 else if (strcmp (name, ".data") == 0)
2180 h->esym.asym.sc = scData;
2181 else if (strcmp (name, ".sdata") == 0)
2182 h->esym.asym.sc = scSData;
2183 else if (strcmp (name, ".rodata") == 0
2184 || strcmp (name, ".rdata") == 0)
2185 h->esym.asym.sc = scRData;
2186 else if (strcmp (name, ".bss") == 0)
2187 h->esym.asym.sc = scBss;
2188 else if (strcmp (name, ".sbss") == 0)
2189 h->esym.asym.sc = scSBss;
2190 else if (strcmp (name, ".init") == 0)
2191 h->esym.asym.sc = scInit;
2192 else if (strcmp (name, ".fini") == 0)
2193 h->esym.asym.sc = scFini;
2195 h->esym.asym.sc = scAbs;
2199 h->esym.asym.reserved = 0;
2200 h->esym.asym.index = indexNil;
2203 if (h->root.root.type == bfd_link_hash_common)
2204 h->esym.asym.value = h->root.root.u.c.size;
2205 else if (h->root.root.type == bfd_link_hash_defined
2206 || h->root.root.type == bfd_link_hash_defweak)
2208 if (h->esym.asym.sc == scCommon)
2209 h->esym.asym.sc = scBss;
2210 else if (h->esym.asym.sc == scSCommon)
2211 h->esym.asym.sc = scSBss;
2213 sec = h->root.root.u.def.section;
2214 output_section = sec->output_section;
2215 if (output_section != NULL)
2216 h->esym.asym.value = (h->root.root.u.def.value
2217 + sec->output_offset
2218 + output_section->vma);
2220 h->esym.asym.value = 0;
2222 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2224 /* Set type and value for a symbol with a function stub. */
2225 h->esym.asym.st = stProc;
2226 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2228 h->esym.asym.value = 0;
2231 output_section = sec->output_section;
2232 if (output_section != NULL)
2233 h->esym.asym.value = (h->root.plt.offset
2234 + sec->output_offset
2235 + output_section->vma);
2237 h->esym.asym.value = 0;
2241 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2242 h->root.root.root.string,
2245 einfo->failed = true;
2252 /* FIXME: Create a runtime procedure table from the .mdebug section.
2255 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2258 struct bfd_link_info *info;
2260 struct ecoff_debug_info *debug;
2263 /* Handle dynamic relocations when doing an Alpha ELF link. */
2266 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2268 struct bfd_link_info *info;
2270 const Elf_Internal_Rela *relocs;
2274 const char *rel_sec_name;
2275 Elf_Internal_Shdr *symtab_hdr;
2276 struct alpha_elf_link_hash_entry **sym_hashes;
2277 struct alpha_elf_got_entry **local_got_entries;
2278 const Elf_Internal_Rela *rel, *relend;
2282 if (info->relocateable)
2285 dynobj = elf_hash_table(info)->dynobj;
2287 elf_hash_table(info)->dynobj = dynobj = abfd;
2290 rel_sec_name = NULL;
2291 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2292 sym_hashes = alpha_elf_sym_hashes(abfd);
2293 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2296 relend = relocs + sec->reloc_count;
2297 for (rel = relocs; rel < relend; ++rel)
2299 unsigned long r_symndx, r_type;
2300 struct alpha_elf_link_hash_entry *h;
2302 r_symndx = ELF64_R_SYM (rel->r_info);
2303 if (r_symndx < symtab_hdr->sh_info)
2307 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2309 while (h->root.root.type == bfd_link_hash_indirect
2310 || h->root.root.type == bfd_link_hash_warning)
2311 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2313 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2315 r_type = ELF64_R_TYPE (rel->r_info);
2319 case R_ALPHA_LITERAL:
2321 struct alpha_elf_got_entry *gotent;
2326 /* Search for and possibly create a got entry. */
2327 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2328 if (gotent->gotobj == abfd &&
2329 gotent->addend == rel->r_addend)
2334 amt = sizeof (struct alpha_elf_got_entry);
2335 gotent = ((struct alpha_elf_got_entry *)
2336 bfd_alloc (abfd, amt));
2340 gotent->gotobj = abfd;
2341 gotent->addend = rel->r_addend;
2342 gotent->got_offset = -1;
2344 gotent->use_count = 1;
2346 gotent->next = h->got_entries;
2347 h->got_entries = gotent;
2349 alpha_elf_tdata (abfd)->total_got_entries++;
2352 gotent->use_count += 1;
2356 /* This is a local .got entry -- record for merge. */
2357 if (!local_got_entries)
2360 size = symtab_hdr->sh_info;
2361 size *= sizeof (struct alpha_elf_got_entry *);
2363 local_got_entries = ((struct alpha_elf_got_entry **)
2364 bfd_alloc (abfd, size));
2365 if (!local_got_entries)
2368 memset (local_got_entries, 0, (size_t) size);
2369 alpha_elf_tdata (abfd)->local_got_entries =
2373 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2374 gotent != NULL && gotent->addend != rel->r_addend;
2375 gotent = gotent->next)
2379 amt = sizeof (struct alpha_elf_got_entry);
2380 gotent = ((struct alpha_elf_got_entry *)
2381 bfd_alloc (abfd, amt));
2385 gotent->gotobj = abfd;
2386 gotent->addend = rel->r_addend;
2387 gotent->got_offset = -1;
2389 gotent->use_count = 1;
2391 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2392 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2394 alpha_elf_tdata(abfd)->total_got_entries++;
2395 alpha_elf_tdata(abfd)->n_local_got_entries++;
2398 gotent->use_count += 1;
2401 /* Remember how this literal is used from its LITUSEs.
2402 This will be important when it comes to decide if we can
2403 create a .plt entry for a function symbol. */
2405 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2410 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2411 flags |= 1 << rel->r_addend;
2413 while (rel+1 < relend &&
2414 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2418 /* No LITUSEs -- presumably the address is not being
2419 loaded for nothing. */
2420 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2423 gotent->flags |= flags;
2426 /* Make a guess as to whether a .plt entry will be needed. */
2427 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2428 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2430 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2435 case R_ALPHA_GPDISP:
2436 case R_ALPHA_GPREL16:
2437 case R_ALPHA_GPREL32:
2438 case R_ALPHA_GPRELHIGH:
2439 case R_ALPHA_GPRELLOW:
2441 /* We don't actually use the .got here, but the sections must
2442 be created before the linker maps input sections to output
2446 if (!elf64_alpha_create_got_section (abfd, info))
2449 /* Make sure the object's gotobj is set to itself so
2450 that we default to every object with its own .got.
2451 We'll merge .gots later once we've collected each
2453 alpha_elf_tdata(abfd)->gotobj = abfd;
2459 case R_ALPHA_SREL16:
2460 case R_ALPHA_SREL32:
2461 case R_ALPHA_SREL64:
2466 case R_ALPHA_REFLONG:
2467 case R_ALPHA_REFQUAD:
2468 if (rel_sec_name == NULL)
2470 rel_sec_name = (bfd_elf_string_from_elf_section
2471 (abfd, elf_elfheader(abfd)->e_shstrndx,
2472 elf_section_data(sec)->rel_hdr.sh_name));
2473 if (rel_sec_name == NULL)
2476 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2477 && strcmp (bfd_get_section_name (abfd, sec),
2478 rel_sec_name+5) == 0);
2481 /* We need to create the section here now whether we eventually
2482 use it or not so that it gets mapped to an output section by
2483 the linker. If not used, we'll kill it in
2484 size_dynamic_sections. */
2487 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2492 sreloc = bfd_make_section (dynobj, rel_sec_name);
2493 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2494 | SEC_LINKER_CREATED | SEC_READONLY);
2495 if (sec->flags & SEC_ALLOC)
2496 flags |= SEC_ALLOC | SEC_LOAD;
2498 || !bfd_set_section_flags (dynobj, sreloc, flags)
2499 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2506 /* Since we havn't seen all of the input symbols yet, we
2507 don't know whether we'll actually need a dynamic relocation
2508 entry for this reloc. So make a record of it. Once we
2509 find out if this thing needs dynamic relocation we'll
2510 expand the relocation sections by the appropriate amount. */
2512 struct alpha_elf_reloc_entry *rent;
2514 for (rent = h->reloc_entries; rent; rent = rent->next)
2515 if (rent->rtype == r_type && rent->srel == sreloc)
2520 amt = sizeof (struct alpha_elf_reloc_entry);
2521 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
2525 rent->srel = sreloc;
2526 rent->rtype = r_type;
2528 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
2529 == (SEC_READONLY | SEC_ALLOC));
2531 rent->next = h->reloc_entries;
2532 h->reloc_entries = rent;
2537 else if (info->shared && (sec->flags & SEC_ALLOC))
2539 /* If this is a shared library, and the section is to be
2540 loaded into memory, we need a RELATIVE reloc. */
2541 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2542 if (sec->flags & SEC_READONLY)
2543 info->flags |= DF_TEXTREL;
2552 /* Adjust a symbol defined by a dynamic object and referenced by a
2553 regular object. The current definition is in some section of the
2554 dynamic object, but we're not including those sections. We have to
2555 change the definition to something the rest of the link can
2559 elf64_alpha_adjust_dynamic_symbol (info, h)
2560 struct bfd_link_info *info;
2561 struct elf_link_hash_entry *h;
2565 struct alpha_elf_link_hash_entry *ah;
2567 dynobj = elf_hash_table(info)->dynobj;
2568 ah = (struct alpha_elf_link_hash_entry *)h;
2570 /* Now that we've seen all of the input symbols, finalize our decision
2571 about whether this symbol should get a .plt entry. */
2573 if (alpha_elf_dynamic_symbol_p (h, info)
2574 && ((h->type == STT_FUNC
2575 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2576 || (h->type == STT_NOTYPE
2577 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2578 /* Don't prevent otherwise valid programs from linking by attempting
2579 to create a new .got entry somewhere. A Correct Solution would be
2580 to add a new .got section to a new object file and let it be merged
2581 somewhere later. But for now don't bother. */
2584 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2586 s = bfd_get_section_by_name(dynobj, ".plt");
2587 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2590 /* The first bit of the .plt is reserved. */
2591 if (s->_raw_size == 0)
2592 s->_raw_size = PLT_HEADER_SIZE;
2594 h->plt.offset = s->_raw_size;
2595 s->_raw_size += PLT_ENTRY_SIZE;
2597 /* If this symbol is not defined in a regular file, and we are not
2598 generating a shared library, then set the symbol to the location
2599 in the .plt. This is required to make function pointers compare
2600 equal between the normal executable and the shared library. */
2602 && h->root.type != bfd_link_hash_defweak)
2604 h->root.u.def.section = s;
2605 h->root.u.def.value = h->plt.offset;
2608 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2609 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2610 BFD_ASSERT (s != NULL);
2611 s->_raw_size += sizeof (Elf64_External_Rela);
2616 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2618 /* If this is a weak symbol, and there is a real definition, the
2619 processor independent code will have arranged for us to see the
2620 real definition first, and we can just use the same value. */
2621 if (h->weakdef != NULL)
2623 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2624 || h->weakdef->root.type == bfd_link_hash_defweak);
2625 h->root.u.def.section = h->weakdef->root.u.def.section;
2626 h->root.u.def.value = h->weakdef->root.u.def.value;
2630 /* This is a reference to a symbol defined by a dynamic object which
2631 is not a function. The Alpha, since it uses .got entries for all
2632 symbols even in regular objects, does not need the hackery of a
2633 .dynbss section and COPY dynamic relocations. */
2638 /* Symbol versioning can create new symbols, and make our old symbols
2639 indirect to the new ones. Consolidate the got and reloc information
2640 in these situations. */
2643 elf64_alpha_merge_ind_symbols (hi, dummy)
2644 struct alpha_elf_link_hash_entry *hi;
2645 PTR dummy ATTRIBUTE_UNUSED;
2647 struct alpha_elf_link_hash_entry *hs;
2649 if (hi->root.root.type != bfd_link_hash_indirect)
2653 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2654 } while (hs->root.root.type == bfd_link_hash_indirect);
2656 /* Merge the flags. Whee. */
2658 hs->flags |= hi->flags;
2660 /* Merge the .got entries. Cannibalize the old symbol's list in
2661 doing so, since we don't need it anymore. */
2663 if (hs->got_entries == NULL)
2664 hs->got_entries = hi->got_entries;
2667 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2669 gsh = hs->got_entries;
2670 for (gi = hi->got_entries; gi ; gi = gin)
2673 for (gs = gsh; gs ; gs = gs->next)
2674 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2676 gi->next = hs->got_entries;
2677 hs->got_entries = gi;
2681 hi->got_entries = NULL;
2683 /* And similar for the reloc entries. */
2685 if (hs->reloc_entries == NULL)
2686 hs->reloc_entries = hi->reloc_entries;
2689 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2691 rsh = hs->reloc_entries;
2692 for (ri = hi->reloc_entries; ri ; ri = rin)
2695 for (rs = rsh; rs ; rs = rs->next)
2696 if (ri->rtype == rs->rtype)
2698 rs->count += ri->count;
2701 ri->next = hs->reloc_entries;
2702 hs->reloc_entries = ri;
2706 hi->reloc_entries = NULL;
2711 /* Is it possible to merge two object file's .got tables? */
2714 elf64_alpha_can_merge_gots (a, b)
2717 int total = alpha_elf_tdata (a)->total_got_entries;
2720 /* Trivial quick fallout test. */
2721 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2724 /* By their nature, local .got entries cannot be merged. */
2725 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2728 /* Failing the common trivial comparison, we must effectively
2729 perform the merge. Not actually performing the merge means that
2730 we don't have to store undo information in case we fail. */
2731 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2733 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2734 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2737 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2738 for (i = 0; i < n; ++i)
2740 struct alpha_elf_got_entry *ae, *be;
2741 struct alpha_elf_link_hash_entry *h;
2744 while (h->root.root.type == bfd_link_hash_indirect
2745 || h->root.root.type == bfd_link_hash_warning)
2746 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2748 for (be = h->got_entries; be ; be = be->next)
2750 if (be->use_count == 0)
2752 if (be->gotobj != b)
2755 for (ae = h->got_entries; ae ; ae = ae->next)
2756 if (ae->gotobj == a && ae->addend == be->addend)
2759 if (++total > MAX_GOT_ENTRIES)
2769 /* Actually merge two .got tables. */
2772 elf64_alpha_merge_gots (a, b)
2775 int total = alpha_elf_tdata (a)->total_got_entries;
2778 /* Remember local expansion. */
2780 int e = alpha_elf_tdata (b)->n_local_got_entries;
2782 alpha_elf_tdata (a)->n_local_got_entries += e;
2785 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2787 struct alpha_elf_got_entry **local_got_entries;
2788 struct alpha_elf_link_hash_entry **hashes;
2789 Elf_Internal_Shdr *symtab_hdr;
2792 /* Let the local .got entries know they are part of a new subsegment. */
2793 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2794 if (local_got_entries)
2796 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2797 for (i = 0; i < n; ++i)
2799 struct alpha_elf_got_entry *ent;
2800 for (ent = local_got_entries[i]; ent; ent = ent->next)
2805 /* Merge the global .got entries. */
2806 hashes = alpha_elf_sym_hashes (bsub);
2807 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2809 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2810 for (i = 0; i < n; ++i)
2812 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2813 struct alpha_elf_link_hash_entry *h;
2816 while (h->root.root.type == bfd_link_hash_indirect
2817 || h->root.root.type == bfd_link_hash_warning)
2818 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2820 start = &h->got_entries;
2821 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2823 if (be->use_count == 0)
2828 if (be->gotobj != b)
2831 for (ae = *start; ae ; ae = ae->next)
2832 if (ae->gotobj == a && ae->addend == be->addend)
2834 ae->flags |= be->flags;
2835 ae->use_count += be->use_count;
2846 alpha_elf_tdata (bsub)->gotobj = a;
2848 alpha_elf_tdata (a)->total_got_entries = total;
2850 /* Merge the two in_got chains. */
2855 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2858 alpha_elf_tdata (bsub)->in_got_link_next = b;
2862 /* Calculate the offsets for the got entries. */
2865 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2866 struct alpha_elf_link_hash_entry *h;
2867 PTR arg ATTRIBUTE_UNUSED;
2869 struct alpha_elf_got_entry *gotent;
2871 if (h->root.root.type == bfd_link_hash_warning)
2872 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2874 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2875 if (gotent->use_count > 0)
2878 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2880 gotent->got_offset = *plge;
2888 elf64_alpha_calc_got_offsets (info)
2889 struct bfd_link_info *info;
2891 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2893 /* First, zero out the .got sizes, as we may be recalculating the
2894 .got after optimizing it. */
2895 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2896 alpha_elf_tdata(i)->got->_raw_size = 0;
2898 /* Next, fill in the offsets for all the global entries. */
2899 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2900 elf64_alpha_calc_got_offsets_for_symbol,
2903 /* Finally, fill in the offsets for the local entries. */
2904 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2906 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2909 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2911 struct alpha_elf_got_entry **local_got_entries, *gotent;
2914 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2915 if (!local_got_entries)
2918 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2919 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2920 if (gotent->use_count > 0)
2922 gotent->got_offset = got_offset;
2927 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2928 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2932 /* Constructs the gots. */
2935 elf64_alpha_size_got_sections (output_bfd, info)
2936 bfd *output_bfd ATTRIBUTE_UNUSED;
2937 struct bfd_link_info *info;
2939 bfd *i, *got_list, *cur_got_obj = NULL;
2940 int something_changed = 0;
2942 got_list = alpha_elf_hash_table (info)->got_list;
2944 /* On the first time through, pretend we have an existing got list
2945 consisting of all of the input files. */
2946 if (got_list == NULL)
2948 for (i = info->input_bfds; i ; i = i->link_next)
2950 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2951 if (this_got == NULL)
2954 /* We are assuming no merging has yet ocurred. */
2955 BFD_ASSERT (this_got == i);
2957 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2959 /* Yikes! A single object file has too many entries. */
2960 (*_bfd_error_handler)
2961 (_("%s: .got subsegment exceeds 64K (size %d)"),
2962 bfd_archive_filename (i),
2963 alpha_elf_tdata (this_got)->total_got_entries * 8);
2967 if (got_list == NULL)
2968 got_list = this_got;
2970 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2971 cur_got_obj = this_got;
2974 /* Strange degenerate case of no got references. */
2975 if (got_list == NULL)
2978 alpha_elf_hash_table (info)->got_list = got_list;
2980 /* Force got offsets to be recalculated. */
2981 something_changed = 1;
2984 cur_got_obj = got_list;
2985 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2988 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2990 elf64_alpha_merge_gots (cur_got_obj, i);
2991 i = alpha_elf_tdata(i)->got_link_next;
2992 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2993 something_changed = 1;
2998 i = alpha_elf_tdata(i)->got_link_next;
3002 /* Once the gots have been merged, fill in the got offsets for
3003 everything therein. */
3004 if (1 || something_changed)
3005 elf64_alpha_calc_got_offsets (info);
3011 elf64_alpha_always_size_sections (output_bfd, info)
3013 struct bfd_link_info *info;
3017 if (info->relocateable)
3020 /* First, take care of the indirect symbols created by versioning. */
3021 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3022 elf64_alpha_merge_ind_symbols,
3025 if (!elf64_alpha_size_got_sections (output_bfd, info))
3028 /* Allocate space for all of the .got subsections. */
3029 i = alpha_elf_hash_table (info)->got_list;
3030 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3032 asection *s = alpha_elf_tdata(i)->got;
3033 if (s->_raw_size > 0)
3035 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3036 if (s->contents == NULL)
3044 /* Work out the sizes of the dynamic relocation entries. */
3047 elf64_alpha_calc_dynrel_sizes (h, info)
3048 struct alpha_elf_link_hash_entry *h;
3049 struct bfd_link_info *info;
3051 if (h->root.root.type == bfd_link_hash_warning)
3052 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3054 /* If the symbol was defined as a common symbol in a regular object
3055 file, and there was no definition in any dynamic object, then the
3056 linker will have allocated space for the symbol in a common
3057 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3058 set. This is done for dynamic symbols in
3059 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3060 symbols, somehow. */
3061 if (((h->root.elf_link_hash_flags
3062 & (ELF_LINK_HASH_DEF_REGULAR
3063 | ELF_LINK_HASH_REF_REGULAR
3064 | ELF_LINK_HASH_DEF_DYNAMIC))
3065 == ELF_LINK_HASH_REF_REGULAR)
3066 && (h->root.root.type == bfd_link_hash_defined
3067 || h->root.root.type == bfd_link_hash_defweak)
3068 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3070 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3073 /* If the symbol is dynamic, we'll need all the relocations in their
3074 natural form. If this is a shared object, and it has been forced
3075 local, we'll need the same number of RELATIVE relocations. */
3077 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3079 struct alpha_elf_reloc_entry *relent;
3081 struct alpha_elf_got_entry *gotent;
3082 bfd_size_type count;
3085 for (relent = h->reloc_entries; relent; relent = relent->next)
3086 if (relent->rtype == R_ALPHA_REFLONG
3087 || relent->rtype == R_ALPHA_REFQUAD)
3089 relent->srel->_raw_size +=
3090 sizeof (Elf64_External_Rela) * relent->count;
3091 if (relent->reltext)
3092 info->flags |= DT_TEXTREL;
3095 dynobj = elf_hash_table(info)->dynobj;
3098 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3101 /* If we are using a .plt entry, subtract one, as the first
3102 reference uses a .rela.plt entry instead. */
3103 if (h->root.plt.offset != MINUS_ONE)
3108 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3109 BFD_ASSERT (srel != NULL);
3110 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3117 /* Set the sizes of the dynamic sections. */
3120 elf64_alpha_size_dynamic_sections (output_bfd, info)
3121 bfd *output_bfd ATTRIBUTE_UNUSED;
3122 struct bfd_link_info *info;
3128 dynobj = elf_hash_table(info)->dynobj;
3129 BFD_ASSERT(dynobj != NULL);
3131 if (elf_hash_table (info)->dynamic_sections_created)
3133 /* Set the contents of the .interp section to the interpreter. */
3136 s = bfd_get_section_by_name (dynobj, ".interp");
3137 BFD_ASSERT (s != NULL);
3138 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3139 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3142 /* Now that we've seen all of the input files, we can decide which
3143 symbols need dynamic relocation entries and which don't. We've
3144 collected information in check_relocs that we can now apply to
3145 size the dynamic relocation sections. */
3146 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3147 elf64_alpha_calc_dynrel_sizes,
3150 /* When building shared libraries, each local .got entry needs a
3156 bfd_size_type count;
3158 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3159 BFD_ASSERT (srel != NULL);
3161 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3163 i = alpha_elf_tdata(i)->got_link_next)
3164 count += alpha_elf_tdata(i)->n_local_got_entries;
3166 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3169 /* else we're not dynamic and by definition we don't need such things. */
3171 /* The check_relocs and adjust_dynamic_symbol entry points have
3172 determined the sizes of the various dynamic sections. Allocate
3175 for (s = dynobj->sections; s != NULL; s = s->next)
3180 if (!(s->flags & SEC_LINKER_CREATED))
3183 /* It's OK to base decisions on the section name, because none
3184 of the dynobj section names depend upon the input files. */
3185 name = bfd_get_section_name (dynobj, s);
3187 /* If we don't need this section, strip it from the output file.
3188 This is to handle .rela.bss and .rela.plt. We must create it
3189 in create_dynamic_sections, because it must be created before
3190 the linker maps input sections to output sections. The
3191 linker does that before adjust_dynamic_symbol is called, and
3192 it is that function which decides whether anything needs to
3193 go into these sections. */
3197 if (strncmp (name, ".rela", 5) == 0)
3199 strip = (s->_raw_size == 0);
3203 if (strcmp(name, ".rela.plt") == 0)
3206 /* We use the reloc_count field as a counter if we need
3207 to copy relocs into the output file. */
3211 else if (strcmp (name, ".plt") != 0)
3213 /* It's not one of our dynamic sections, so don't allocate space. */
3218 _bfd_strip_section_from_output (info, s);
3221 /* Allocate memory for the section contents. */
3222 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3223 if (s->contents == NULL && s->_raw_size != 0)
3228 if (elf_hash_table (info)->dynamic_sections_created)
3230 /* Add some entries to the .dynamic section. We fill in the
3231 values later, in elf64_alpha_finish_dynamic_sections, but we
3232 must add the entries now so that we get the correct size for
3233 the .dynamic section. The DT_DEBUG entry is filled in by the
3234 dynamic linker and used by the debugger. */
3235 #define add_dynamic_entry(TAG, VAL) \
3236 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3240 if (!add_dynamic_entry (DT_DEBUG, 0))
3246 if (!add_dynamic_entry (DT_PLTGOT, 0)
3247 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3248 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3249 || !add_dynamic_entry (DT_JMPREL, 0))
3253 if (!add_dynamic_entry (DT_RELA, 0)
3254 || !add_dynamic_entry (DT_RELASZ, 0)
3255 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3258 if (info->flags & DF_TEXTREL)
3260 if (!add_dynamic_entry (DT_TEXTREL, 0))
3264 #undef add_dynamic_entry
3269 /* Relocate an Alpha ELF section. */
3272 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3273 contents, relocs, local_syms, local_sections)
3275 struct bfd_link_info *info;
3277 asection *input_section;
3279 Elf_Internal_Rela *relocs;
3280 Elf_Internal_Sym *local_syms;
3281 asection **local_sections;
3283 Elf_Internal_Shdr *symtab_hdr;
3284 Elf_Internal_Rela *rel;
3285 Elf_Internal_Rela *relend;
3286 asection *sec, *sgot, *srel, *srelgot;
3287 bfd *dynobj, *gotobj;
3289 boolean ret_val = true;
3291 srelgot = srel = NULL;
3292 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3293 dynobj = elf_hash_table (info)->dynobj;
3296 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3299 /* Find the gp value for this input bfd. */
3302 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3305 sgot = alpha_elf_tdata (gotobj)->got;
3306 gp = _bfd_get_gp_value (gotobj);
3309 gp = (sgot->output_section->vma
3310 + sgot->output_offset
3312 _bfd_set_gp_value (gotobj, gp);
3317 relend = relocs + input_section->reloc_count;
3318 for (; rel < relend; rel++)
3321 reloc_howto_type *howto;
3322 unsigned long r_symndx;
3323 struct alpha_elf_link_hash_entry *h;
3324 Elf_Internal_Sym *sym;
3327 bfd_reloc_status_type r;
3329 r_type = ELF64_R_TYPE(rel->r_info);
3330 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3332 bfd_set_error (bfd_error_bad_value);
3335 howto = elf64_alpha_howto_table + r_type;
3337 r_symndx = ELF64_R_SYM(rel->r_info);
3339 if (info->relocateable)
3341 /* This is a relocateable link. We don't have to change
3342 anything, unless the reloc is against a section symbol,
3343 in which case we have to adjust according to where the
3344 section symbol winds up in the output section. */
3346 /* The symbol associated with GPDISP and LITUSE is
3347 immaterial. Only the addend is significant. */
3348 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3351 if (r_symndx < symtab_hdr->sh_info)
3353 sym = local_syms + r_symndx;
3354 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3356 sec = local_sections[r_symndx];
3357 rel->r_addend += sec->output_offset + sym->st_value;
3364 /* This is a final link. */
3370 if (r_symndx < symtab_hdr->sh_info)
3372 sym = local_syms + r_symndx;
3373 sec = local_sections[r_symndx];
3374 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3378 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3380 while (h->root.root.type == bfd_link_hash_indirect
3381 || h->root.root.type == bfd_link_hash_warning)
3382 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3384 if (h->root.root.type == bfd_link_hash_defined
3385 || h->root.root.type == bfd_link_hash_defweak)
3387 sec = h->root.root.u.def.section;
3389 if (sec->output_section == NULL)
3393 relocation = (h->root.root.u.def.value
3394 + sec->output_section->vma
3395 + sec->output_offset);
3398 else if (h->root.root.type == bfd_link_hash_undefweak)
3400 else if (info->shared
3401 && (!info->symbolic || info->allow_shlib_undefined)
3402 && !info->no_undefined
3403 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3407 if (!((*info->callbacks->undefined_symbol)
3408 (info, h->root.root.root.string, input_bfd,
3409 input_section, rel->r_offset,
3410 (!info->shared || info->no_undefined
3411 || ELF_ST_VISIBILITY (h->root.other)))))
3416 addend = rel->r_addend;
3420 case R_ALPHA_GPDISP:
3422 bfd_byte *p_ldah, *p_lda;
3424 BFD_ASSERT(gp != 0);
3426 relocation = (input_section->output_section->vma
3427 + input_section->output_offset
3430 p_ldah = contents + rel->r_offset - input_section->vma;
3431 p_lda = p_ldah + rel->r_addend;
3433 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3438 case R_ALPHA_LITERAL:
3440 struct alpha_elf_got_entry *gotent;
3441 boolean dynamic_symbol;
3443 BFD_ASSERT(sgot != NULL);
3444 BFD_ASSERT(gp != 0);
3448 gotent = h->got_entries;
3449 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3453 gotent = (alpha_elf_tdata(input_bfd)->
3454 local_got_entries[r_symndx]);
3455 dynamic_symbol = false;
3457 /* Need to adjust local GOT entries' addends for SEC_MERGE
3458 unless it has been done already. */
3459 if ((sec->flags & SEC_MERGE)
3460 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3461 && (elf_section_data (sec)->sec_info_type
3462 == ELF_INFO_TYPE_MERGE)
3463 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3465 struct alpha_elf_got_entry *ent;
3468 for (ent = gotent; ent; ent = ent->next)
3470 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3471 if (ent->use_count == 0)
3475 _bfd_merged_section_offset (output_bfd, &msec,
3476 elf_section_data (sec)->
3481 ent->addend -= sym->st_value;
3482 ent->addend += msec->output_section->vma
3483 + msec->output_offset
3484 - sec->output_section->vma
3485 - sec->output_offset;
3490 BFD_ASSERT(gotent != NULL);
3492 while (gotent->gotobj != gotobj || gotent->addend != addend)
3493 gotent = gotent->next;
3495 BFD_ASSERT(gotent->use_count >= 1);
3497 /* Initialize the .got entry's value. */
3498 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3500 bfd_put_64 (output_bfd, relocation + addend,
3501 sgot->contents + gotent->got_offset);
3503 /* If the symbol has been forced local, output a
3504 RELATIVE reloc, otherwise it will be handled in
3505 finish_dynamic_symbol. */
3506 if (info->shared && !dynamic_symbol)
3508 Elf_Internal_Rela outrel;
3510 BFD_ASSERT(srelgot != NULL);
3512 outrel.r_offset = (sgot->output_section->vma
3513 + sgot->output_offset
3514 + gotent->got_offset);
3515 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3516 outrel.r_addend = relocation + addend;
3518 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3519 ((Elf64_External_Rela *)
3521 + srelgot->reloc_count++);
3522 BFD_ASSERT (sizeof (Elf64_External_Rela)
3523 * srelgot->reloc_count
3524 <= srelgot->_cooked_size);
3527 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3530 /* Figure the gprel relocation. */
3532 relocation = (sgot->output_section->vma
3533 + sgot->output_offset
3534 + gotent->got_offset);
3537 /* overflow handled by _bfd_final_link_relocate */
3540 case R_ALPHA_GPREL16:
3541 case R_ALPHA_GPREL32:
3542 case R_ALPHA_GPRELLOW:
3543 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3545 (*_bfd_error_handler)
3546 (_("%s: gp-relative relocation against dynamic symbol %s"),
3547 bfd_archive_filename (input_bfd), h->root.root.root.string);
3550 BFD_ASSERT(gp != 0);
3554 case R_ALPHA_GPRELHIGH:
3555 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3557 (*_bfd_error_handler)
3558 (_("%s: gp-relative relocation against dynamic symbol %s"),
3559 bfd_archive_filename (input_bfd), h->root.root.root.string);
3562 BFD_ASSERT(gp != 0);
3564 relocation += addend;
3566 relocation = (((bfd_signed_vma) relocation >> 16)
3567 + ((relocation >> 15) & 1));
3571 /* A call to a dynamic symbol is definitely out of range of
3572 the 16-bit displacement. Don't bother writing anything. */
3573 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3580 case R_ALPHA_BRADDR:
3581 /* The regular PC-relative stuff measures from the start of
3582 the instruction rather than the end. */
3591 /* The regular PC-relative stuff measures from the start of
3592 the instruction rather than the end. */
3595 /* The source and destination gp must be the same. Note that
3596 the source will always have an assigned gp, since we forced
3597 one in check_relocs, but that the destination may not, as
3598 it might not have had any relocations at all. Also take
3599 care not to crash if H is an undefined symbol. */
3600 if (h != NULL && sec != NULL
3601 && alpha_elf_tdata (sec->owner)->gotobj
3602 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
3604 (*_bfd_error_handler)
3605 (_("%s: change in gp: BRSGP %s"),
3606 bfd_archive_filename (input_bfd), h->root.root.root.string);
3610 /* The symbol should be marked either NOPV or STD_GPLOAD. */
3612 other = h->root.other;
3614 other = sym->st_other;
3615 switch (other & STO_ALPHA_STD_GPLOAD)
3617 case STO_ALPHA_NOPV:
3619 case STO_ALPHA_STD_GPLOAD:
3624 name = h->root.root.root.string;
3627 name = (bfd_elf_string_from_elf_section
3628 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3630 name = _("<unknown>");
3631 else if (name[0] == 0)
3632 name = bfd_section_name (input_bfd, sec);
3634 (*_bfd_error_handler)
3635 (_("%s: !samegp reloc against symbol without .prologue: %s"),
3636 bfd_archive_filename (input_bfd), name);
3644 case R_ALPHA_REFLONG:
3645 case R_ALPHA_REFQUAD:
3647 Elf_Internal_Rela outrel;
3649 /* Careful here to remember RELATIVE relocations for global
3650 variables for symbolic shared objects. */
3652 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3654 BFD_ASSERT(h->root.dynindx != -1);
3655 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3656 outrel.r_addend = addend;
3657 addend = 0, relocation = 0;
3659 else if (info->shared
3661 && (input_section->flags & SEC_ALLOC))
3663 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3664 outrel.r_addend = relocation + addend;
3673 name = (bfd_elf_string_from_elf_section
3674 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3675 elf_section_data(input_section)->rel_hdr.sh_name));
3676 BFD_ASSERT(name != NULL);
3678 srel = bfd_get_section_by_name (dynobj, name);
3679 BFD_ASSERT(srel != NULL);
3683 _bfd_elf_section_offset (output_bfd, info, input_section,
3685 if ((outrel.r_offset | 1) != (bfd_vma) -1)
3686 outrel.r_offset += (input_section->output_section->vma
3687 + input_section->output_offset);
3689 memset (&outrel, 0, sizeof outrel);
3691 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3692 ((Elf64_External_Rela *)
3694 + srel->reloc_count++);
3695 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3696 <= srel->_cooked_size);
3700 case R_ALPHA_SREL32:
3701 case R_ALPHA_SREL64:
3702 /* ??? .eh_frame references to discarded sections will be smashed
3703 to relocations against SHN_UNDEF. The .eh_frame format allows
3704 NULL to be encoded as 0 in any format, so this works here. */
3706 howto = (elf64_alpha_howto_table
3707 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
3712 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3713 contents, rel->r_offset, relocation,
3723 case bfd_reloc_overflow:
3727 /* Don't warn if the overflow is due to pc relative reloc
3728 against discarded section. Section optimization code should
3731 if (r_symndx < symtab_hdr->sh_info
3732 && sec != NULL && howto->pc_relative
3733 && elf_discarded_section (sec))
3737 name = h->root.root.root.string;
3740 name = (bfd_elf_string_from_elf_section
3741 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3745 name = bfd_section_name (input_bfd, sec);
3747 if (! ((*info->callbacks->reloc_overflow)
3748 (info, name, howto->name, (bfd_vma) 0,
3749 input_bfd, input_section, rel->r_offset)))
3755 case bfd_reloc_outofrange:
3763 /* Finish up dynamic symbol handling. We set the contents of various
3764 dynamic sections here. */
3767 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3769 struct bfd_link_info *info;
3770 struct elf_link_hash_entry *h;
3771 Elf_Internal_Sym *sym;
3773 bfd *dynobj = elf_hash_table(info)->dynobj;
3775 if (h->plt.offset != MINUS_ONE)
3777 /* Fill in the .plt entry for this symbol. */
3778 asection *splt, *sgot, *srel;
3779 Elf_Internal_Rela outrel;
3780 bfd_vma got_addr, plt_addr;
3782 struct alpha_elf_got_entry *gotent;
3784 BFD_ASSERT (h->dynindx != -1);
3786 /* The first .got entry will be updated by the .plt with the
3787 address of the target function. */
3788 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3789 BFD_ASSERT (gotent && gotent->addend == 0);
3791 splt = bfd_get_section_by_name (dynobj, ".plt");
3792 BFD_ASSERT (splt != NULL);
3793 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3794 BFD_ASSERT (srel != NULL);
3795 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3796 BFD_ASSERT (sgot != NULL);
3798 got_addr = (sgot->output_section->vma
3799 + sgot->output_offset
3800 + gotent->got_offset);
3801 plt_addr = (splt->output_section->vma
3802 + splt->output_offset
3805 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3807 /* Fill in the entry in the procedure linkage table. */
3809 bfd_vma insn1, insn2, insn3;
3811 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3812 insn2 = PLT_ENTRY_WORD2;
3813 insn3 = PLT_ENTRY_WORD3;
3815 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3816 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3817 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3820 /* Fill in the entry in the .rela.plt section. */
3821 outrel.r_offset = got_addr;
3822 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3823 outrel.r_addend = 0;
3825 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3826 ((Elf64_External_Rela *)srel->contents
3829 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3831 /* Mark the symbol as undefined, rather than as defined in the
3832 .plt section. Leave the value alone. */
3833 sym->st_shndx = SHN_UNDEF;
3836 /* Fill in the entries in the .got. */
3837 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3839 /* Subsequent .got entries will continue to bounce through the .plt. */
3842 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3843 BFD_ASSERT (! info->shared || srel != NULL);
3845 gotent = gotent->next;
3848 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3849 BFD_ASSERT(sgot != NULL);
3850 BFD_ASSERT(gotent->addend == 0);
3852 bfd_put_64 (output_bfd, plt_addr,
3853 sgot->contents + gotent->got_offset);
3857 outrel.r_offset = (sgot->output_section->vma
3858 + sgot->output_offset
3859 + gotent->got_offset);
3860 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3861 outrel.r_addend = plt_addr;
3863 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3864 ((Elf64_External_Rela *)
3866 + srel->reloc_count++);
3867 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3868 <= srel->_cooked_size);
3871 gotent = gotent->next;
3873 while (gotent != NULL);
3876 else if (alpha_elf_dynamic_symbol_p (h, info))
3878 /* Fill in the dynamic relocations for this symbol's .got entries. */
3880 Elf_Internal_Rela outrel;
3881 struct alpha_elf_got_entry *gotent;
3883 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3884 BFD_ASSERT (srel != NULL);
3886 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3887 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3889 gotent = gotent->next)
3891 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3892 outrel.r_offset = (sgot->output_section->vma
3893 + sgot->output_offset
3894 + gotent->got_offset);
3895 outrel.r_addend = gotent->addend;
3897 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3898 ((Elf64_External_Rela *)srel->contents
3899 + srel->reloc_count++));
3900 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3901 <= srel->_cooked_size);
3905 /* Mark some specially defined symbols as absolute. */
3906 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3907 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3908 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3909 sym->st_shndx = SHN_ABS;
3914 /* Finish up the dynamic sections. */
3917 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3919 struct bfd_link_info *info;
3924 dynobj = elf_hash_table (info)->dynobj;
3925 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3927 if (elf_hash_table (info)->dynamic_sections_created)
3930 Elf64_External_Dyn *dyncon, *dynconend;
3932 splt = bfd_get_section_by_name (dynobj, ".plt");
3933 BFD_ASSERT (splt != NULL && sdyn != NULL);
3935 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3936 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3937 for (; dyncon < dynconend; dyncon++)
3939 Elf_Internal_Dyn dyn;
3943 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3958 /* My interpretation of the TIS v1.1 ELF document indicates
3959 that RELASZ should not include JMPREL. This is not what
3960 the rest of the BFD does. It is, however, what the
3961 glibc ld.so wants. Do this fixup here until we found
3962 out who is right. */
3963 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3967 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3972 s = bfd_get_section_by_name (output_bfd, name);
3973 dyn.d_un.d_ptr = (s ? s->vma : 0);
3977 s = bfd_get_section_by_name (output_bfd, name);
3979 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3983 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3986 /* Initialize the PLT0 entry */
3987 if (splt->_raw_size > 0)
3989 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3990 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3991 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3992 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3994 /* The next two words will be filled in by ld.so */
3995 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3996 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
3998 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
4006 /* We need to use a special link routine to handle the .mdebug section.
4007 We need to merge all instances of these sections together, not write
4008 them all out sequentially. */
4011 elf64_alpha_final_link (abfd, info)
4013 struct bfd_link_info *info;
4016 struct bfd_link_order *p;
4017 asection *mdebug_sec;
4018 struct ecoff_debug_info debug;
4019 const struct ecoff_debug_swap *swap
4020 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4021 HDRR *symhdr = &debug.symbolic_header;
4022 PTR mdebug_handle = NULL;
4024 /* Go through the sections and collect the mdebug information. */
4026 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4028 if (strcmp (o->name, ".mdebug") == 0)
4030 struct extsym_info einfo;
4032 /* We have found the .mdebug section in the output file.
4033 Look through all the link_orders comprising it and merge
4034 the information together. */
4035 symhdr->magic = swap->sym_magic;
4036 /* FIXME: What should the version stamp be? */
4038 symhdr->ilineMax = 0;
4042 symhdr->isymMax = 0;
4043 symhdr->ioptMax = 0;
4044 symhdr->iauxMax = 0;
4046 symhdr->issExtMax = 0;
4049 symhdr->iextMax = 0;
4051 /* We accumulate the debugging information itself in the
4052 debug_info structure. */
4054 debug.external_dnr = NULL;
4055 debug.external_pdr = NULL;
4056 debug.external_sym = NULL;
4057 debug.external_opt = NULL;
4058 debug.external_aux = NULL;
4060 debug.ssext = debug.ssext_end = NULL;
4061 debug.external_fdr = NULL;
4062 debug.external_rfd = NULL;
4063 debug.external_ext = debug.external_ext_end = NULL;
4065 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4066 if (mdebug_handle == (PTR) NULL)
4075 static const char * const name[] =
4077 ".text", ".init", ".fini", ".data",
4078 ".rodata", ".sdata", ".sbss", ".bss"
4080 static const int sc[] = { scText, scInit, scFini, scData,
4081 scRData, scSData, scSBss, scBss };
4084 esym.cobol_main = 0;
4088 esym.asym.iss = issNil;
4089 esym.asym.st = stLocal;
4090 esym.asym.reserved = 0;
4091 esym.asym.index = indexNil;
4092 for (i = 0; i < 8; i++)
4094 esym.asym.sc = sc[i];
4095 s = bfd_get_section_by_name (abfd, name[i]);
4098 esym.asym.value = s->vma;
4099 last = s->vma + s->_raw_size;
4102 esym.asym.value = last;
4104 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4110 for (p = o->link_order_head;
4111 p != (struct bfd_link_order *) NULL;
4114 asection *input_section;
4116 const struct ecoff_debug_swap *input_swap;
4117 struct ecoff_debug_info input_debug;
4121 if (p->type != bfd_indirect_link_order)
4123 if (p->type == bfd_fill_link_order)
4128 input_section = p->u.indirect.section;
4129 input_bfd = input_section->owner;
4131 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4132 || (get_elf_backend_data (input_bfd)
4133 ->elf_backend_ecoff_debug_swap) == NULL)
4135 /* I don't know what a non ALPHA ELF bfd would be
4136 doing with a .mdebug section, but I don't really
4137 want to deal with it. */
4141 input_swap = (get_elf_backend_data (input_bfd)
4142 ->elf_backend_ecoff_debug_swap);
4144 BFD_ASSERT (p->size == input_section->_raw_size);
4146 /* The ECOFF linking code expects that we have already
4147 read in the debugging information and set up an
4148 ecoff_debug_info structure, so we do that now. */
4149 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4153 if (! (bfd_ecoff_debug_accumulate
4154 (mdebug_handle, abfd, &debug, swap, input_bfd,
4155 &input_debug, input_swap, info)))
4158 /* Loop through the external symbols. For each one with
4159 interesting information, try to find the symbol in
4160 the linker global hash table and save the information
4161 for the output external symbols. */
4162 eraw_src = input_debug.external_ext;
4163 eraw_end = (eraw_src
4164 + (input_debug.symbolic_header.iextMax
4165 * input_swap->external_ext_size));
4167 eraw_src < eraw_end;
4168 eraw_src += input_swap->external_ext_size)
4172 struct alpha_elf_link_hash_entry *h;
4174 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4175 if (ext.asym.sc == scNil
4176 || ext.asym.sc == scUndefined
4177 || ext.asym.sc == scSUndefined)
4180 name = input_debug.ssext + ext.asym.iss;
4181 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4182 name, false, false, true);
4183 if (h == NULL || h->esym.ifd != -2)
4189 < input_debug.symbolic_header.ifdMax);
4190 ext.ifd = input_debug.ifdmap[ext.ifd];
4196 /* Free up the information we just read. */
4197 free (input_debug.line);
4198 free (input_debug.external_dnr);
4199 free (input_debug.external_pdr);
4200 free (input_debug.external_sym);
4201 free (input_debug.external_opt);
4202 free (input_debug.external_aux);
4203 free (input_debug.ss);
4204 free (input_debug.ssext);
4205 free (input_debug.external_fdr);
4206 free (input_debug.external_rfd);
4207 free (input_debug.external_ext);
4209 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4210 elf_link_input_bfd ignores this section. */
4211 input_section->flags &=~ SEC_HAS_CONTENTS;
4214 /* Build the external symbol information. */
4217 einfo.debug = &debug;
4219 einfo.failed = false;
4220 elf_link_hash_traverse (elf_hash_table (info),
4221 elf64_alpha_output_extsym,
4226 /* Set the size of the .mdebug section. */
4227 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4229 /* Skip this section later on (I don't think this currently
4230 matters, but someday it might). */
4231 o->link_order_head = (struct bfd_link_order *) NULL;
4237 /* Invoke the regular ELF backend linker to do all the work. */
4238 if (! bfd_elf64_bfd_final_link (abfd, info))
4241 /* Now write out the computed sections. */
4243 /* The .got subsections... */
4245 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4246 for (i = alpha_elf_hash_table(info)->got_list;
4248 i = alpha_elf_tdata(i)->got_link_next)
4252 /* elf_bfd_final_link already did everything in dynobj. */
4256 sgot = alpha_elf_tdata(i)->got;
4257 if (! bfd_set_section_contents (abfd, sgot->output_section,
4259 (file_ptr) sgot->output_offset,
4265 if (mdebug_sec != (asection *) NULL)
4267 BFD_ASSERT (abfd->output_has_begun);
4268 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4270 mdebug_sec->filepos))
4273 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4279 static enum elf_reloc_type_class
4280 elf64_alpha_reloc_type_class (rela)
4281 const Elf_Internal_Rela *rela;
4283 switch ((int) ELF64_R_TYPE (rela->r_info))
4285 case R_ALPHA_RELATIVE:
4286 return reloc_class_relative;
4287 case R_ALPHA_JMP_SLOT:
4288 return reloc_class_plt;
4290 return reloc_class_copy;
4292 return reloc_class_normal;
4296 /* ECOFF swapping routines. These are used when dealing with the
4297 .mdebug section, which is in the ECOFF debugging format. Copied
4298 from elf32-mips.c. */
4299 static const struct ecoff_debug_swap
4300 elf64_alpha_ecoff_debug_swap =
4302 /* Symbol table magic number. */
4304 /* Alignment of debugging information. E.g., 4. */
4306 /* Sizes of external symbolic information. */
4307 sizeof (struct hdr_ext),
4308 sizeof (struct dnr_ext),
4309 sizeof (struct pdr_ext),
4310 sizeof (struct sym_ext),
4311 sizeof (struct opt_ext),
4312 sizeof (struct fdr_ext),
4313 sizeof (struct rfd_ext),
4314 sizeof (struct ext_ext),
4315 /* Functions to swap in external symbolic data. */
4324 _bfd_ecoff_swap_tir_in,
4325 _bfd_ecoff_swap_rndx_in,
4326 /* Functions to swap out external symbolic data. */
4335 _bfd_ecoff_swap_tir_out,
4336 _bfd_ecoff_swap_rndx_out,
4337 /* Function to read in symbolic data. */
4338 elf64_alpha_read_ecoff_info
4341 /* Use a non-standard hash bucket size of 8. */
4343 const struct elf_size_info alpha_elf_size_info =
4345 sizeof (Elf64_External_Ehdr),
4346 sizeof (Elf64_External_Phdr),
4347 sizeof (Elf64_External_Shdr),
4348 sizeof (Elf64_External_Rel),
4349 sizeof (Elf64_External_Rela),
4350 sizeof (Elf64_External_Sym),
4351 sizeof (Elf64_External_Dyn),
4352 sizeof (Elf_External_Note),
4356 ELFCLASS64, EV_CURRENT,
4357 bfd_elf64_write_out_phdrs,
4358 bfd_elf64_write_shdrs_and_ehdr,
4359 bfd_elf64_write_relocs,
4360 bfd_elf64_swap_symbol_out,
4361 bfd_elf64_slurp_reloc_table,
4362 bfd_elf64_slurp_symbol_table,
4363 bfd_elf64_swap_dyn_in,
4364 bfd_elf64_swap_dyn_out,
4371 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4372 #define TARGET_LITTLE_NAME "elf64-alpha"
4373 #define ELF_ARCH bfd_arch_alpha
4374 #define ELF_MACHINE_CODE EM_ALPHA
4375 #define ELF_MAXPAGESIZE 0x10000
4377 #define bfd_elf64_bfd_link_hash_table_create \
4378 elf64_alpha_bfd_link_hash_table_create
4380 #define bfd_elf64_bfd_reloc_type_lookup \
4381 elf64_alpha_bfd_reloc_type_lookup
4382 #define elf_info_to_howto \
4383 elf64_alpha_info_to_howto
4385 #define bfd_elf64_mkobject \
4386 elf64_alpha_mkobject
4387 #define elf_backend_object_p \
4388 elf64_alpha_object_p
4390 #define elf_backend_section_from_shdr \
4391 elf64_alpha_section_from_shdr
4392 #define elf_backend_section_flags \
4393 elf64_alpha_section_flags
4394 #define elf_backend_fake_sections \
4395 elf64_alpha_fake_sections
4397 #define bfd_elf64_bfd_is_local_label_name \
4398 elf64_alpha_is_local_label_name
4399 #define bfd_elf64_find_nearest_line \
4400 elf64_alpha_find_nearest_line
4401 #define bfd_elf64_bfd_relax_section \
4402 elf64_alpha_relax_section
4404 #define elf_backend_add_symbol_hook \
4405 elf64_alpha_add_symbol_hook
4406 #define elf_backend_check_relocs \
4407 elf64_alpha_check_relocs
4408 #define elf_backend_create_dynamic_sections \
4409 elf64_alpha_create_dynamic_sections
4410 #define elf_backend_adjust_dynamic_symbol \
4411 elf64_alpha_adjust_dynamic_symbol
4412 #define elf_backend_always_size_sections \
4413 elf64_alpha_always_size_sections
4414 #define elf_backend_size_dynamic_sections \
4415 elf64_alpha_size_dynamic_sections
4416 #define elf_backend_relocate_section \
4417 elf64_alpha_relocate_section
4418 #define elf_backend_finish_dynamic_symbol \
4419 elf64_alpha_finish_dynamic_symbol
4420 #define elf_backend_finish_dynamic_sections \
4421 elf64_alpha_finish_dynamic_sections
4422 #define bfd_elf64_bfd_final_link \
4423 elf64_alpha_final_link
4424 #define elf_backend_reloc_type_class \
4425 elf64_alpha_reloc_type_class
4427 #define elf_backend_ecoff_debug_swap \
4428 &elf64_alpha_ecoff_debug_swap
4430 #define elf_backend_size_info \
4433 /* A few constants that determine how the .plt section is set up. */
4434 #define elf_backend_want_got_plt 0
4435 #define elf_backend_plt_readonly 0
4436 #define elf_backend_want_plt_sym 1
4437 #define elf_backend_got_header_size 0
4438 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4440 #include "elf64-target.h"