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 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
52 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
54 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
66 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd *, bfd_reloc_code_real_type));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
77 static boolean elf64_alpha_section_flags
78 PARAMS((flagword *, Elf64_Internal_Shdr *));
79 static boolean elf64_alpha_fake_sections
80 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
81 static boolean elf64_alpha_create_got_section
82 PARAMS((bfd *, struct bfd_link_info *));
83 static boolean elf64_alpha_create_dynamic_sections
84 PARAMS((bfd *, struct bfd_link_info *));
86 static boolean elf64_alpha_read_ecoff_info
87 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
88 static boolean elf64_alpha_is_local_label_name
89 PARAMS((bfd *, const char *));
90 static boolean elf64_alpha_find_nearest_line
91 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
92 const char **, unsigned int *));
94 #if defined(__STDC__) || defined(ALMOST_STDC)
95 struct alpha_elf_link_hash_entry;
98 static boolean elf64_alpha_output_extsym
99 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
101 static boolean elf64_alpha_can_merge_gots
102 PARAMS((bfd *, bfd *));
103 static void elf64_alpha_merge_gots
104 PARAMS((bfd *, bfd *));
105 static boolean elf64_alpha_calc_got_offsets_for_symbol
106 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
107 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
108 static boolean elf64_alpha_size_got_sections
109 PARAMS ((bfd *, struct bfd_link_info *));
110 static boolean elf64_alpha_always_size_sections
111 PARAMS ((bfd *, struct bfd_link_info *));
112 static boolean elf64_alpha_calc_dynrel_sizes
113 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
114 static boolean elf64_alpha_add_symbol_hook
115 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
116 const char **, flagword *, asection **, bfd_vma *));
117 static boolean elf64_alpha_check_relocs
118 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
119 const Elf_Internal_Rela *));
120 static boolean elf64_alpha_adjust_dynamic_symbol
121 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
122 static boolean elf64_alpha_size_dynamic_sections
123 PARAMS((bfd *, struct bfd_link_info *));
124 static boolean elf64_alpha_relocate_section
125 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
126 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
127 static boolean elf64_alpha_finish_dynamic_symbol
128 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
129 Elf_Internal_Sym *));
130 static boolean elf64_alpha_finish_dynamic_sections
131 PARAMS((bfd *, struct bfd_link_info *));
132 static boolean elf64_alpha_final_link
133 PARAMS((bfd *, struct bfd_link_info *));
134 static boolean elf64_alpha_merge_ind_symbols
135 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
136 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
137 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
138 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
139 PARAMS ((const Elf_Internal_Rela *));
141 struct alpha_elf_link_hash_entry
143 struct elf_link_hash_entry root;
145 /* External symbol information. */
148 /* Cumulative flags for all the .got entries. */
151 /* Contexts (LITUSE) in which a literal was referenced. */
152 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
153 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
154 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
155 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
157 /* Used to implement multiple .got subsections. */
158 struct alpha_elf_got_entry
160 struct alpha_elf_got_entry *next;
162 /* which .got subsection? */
165 /* the addend in effect for this entry. */
168 /* the .got offset for this entry. */
173 /* Additional flags. */
174 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
175 #define ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED 0x20
180 /* used to count non-got, non-plt relocations for delayed sizing
181 of relocation sections. */
182 struct alpha_elf_reloc_entry
184 struct alpha_elf_reloc_entry *next;
186 /* which .reloc section? */
189 /* what kind of relocation? */
192 /* is this against read-only section? */
193 unsigned int reltext : 1;
195 /* how many did we find? */
200 /* Alpha ELF linker hash table. */
202 struct alpha_elf_link_hash_table
204 struct elf_link_hash_table root;
206 /* The head of a list of .got subsections linked through
207 alpha_elf_tdata(abfd)->got_link_next. */
211 /* Look up an entry in a Alpha ELF linker hash table. */
213 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
214 ((struct alpha_elf_link_hash_entry *) \
215 elf_link_hash_lookup (&(table)->root, (string), (create), \
218 /* Traverse a Alpha ELF linker hash table. */
220 #define alpha_elf_link_hash_traverse(table, func, info) \
221 (elf_link_hash_traverse \
223 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
226 /* Get the Alpha ELF linker hash table from a link_info structure. */
228 #define alpha_elf_hash_table(p) \
229 ((struct alpha_elf_link_hash_table *) ((p)->hash))
231 /* Get the object's symbols as our own entry type. */
233 #define alpha_elf_sym_hashes(abfd) \
234 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
236 /* Should we do dynamic things to this symbol? */
239 alpha_elf_dynamic_symbol_p (h, info)
240 struct elf_link_hash_entry *h;
241 struct bfd_link_info *info;
246 while (h->root.type == bfd_link_hash_indirect
247 || h->root.type == bfd_link_hash_warning)
248 h = (struct elf_link_hash_entry *) h->root.u.i.link;
250 if (h->dynindx == -1)
253 if (h->root.type == bfd_link_hash_undefweak
254 || h->root.type == bfd_link_hash_defweak)
257 switch (ELF_ST_VISIBILITY (h->other))
265 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
270 if ((info->shared && !info->symbolic)
271 || ((h->elf_link_hash_flags
272 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
273 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
279 /* Create an entry in a Alpha ELF linker hash table. */
281 static struct bfd_hash_entry *
282 elf64_alpha_link_hash_newfunc (entry, table, string)
283 struct bfd_hash_entry *entry;
284 struct bfd_hash_table *table;
287 struct alpha_elf_link_hash_entry *ret =
288 (struct alpha_elf_link_hash_entry *) entry;
290 /* Allocate the structure if it has not already been allocated by a
292 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
293 ret = ((struct alpha_elf_link_hash_entry *)
294 bfd_hash_allocate (table,
295 sizeof (struct alpha_elf_link_hash_entry)));
296 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
297 return (struct bfd_hash_entry *) ret;
299 /* Call the allocation method of the superclass. */
300 ret = ((struct alpha_elf_link_hash_entry *)
301 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
303 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
305 /* Set local fields. */
306 memset (&ret->esym, 0, sizeof (EXTR));
307 /* We use -2 as a marker to indicate that the information has
308 not been set. -1 means there is no associated ifd. */
311 ret->got_entries = NULL;
312 ret->reloc_entries = NULL;
315 return (struct bfd_hash_entry *) ret;
318 /* Create a Alpha ELF linker hash table. */
320 static struct bfd_link_hash_table *
321 elf64_alpha_bfd_link_hash_table_create (abfd)
324 struct alpha_elf_link_hash_table *ret;
325 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
327 ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
328 if (ret == (struct alpha_elf_link_hash_table *) NULL)
331 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
332 elf64_alpha_link_hash_newfunc))
338 return &ret->root.root;
341 /* We have some private fields hanging off of the elf_tdata structure. */
343 struct alpha_elf_obj_tdata
345 struct elf_obj_tdata root;
347 /* For every input file, these are the got entries for that object's
349 struct alpha_elf_got_entry ** local_got_entries;
351 /* For every input file, this is the object that owns the got that
352 this input file uses. */
355 /* For every got, this is a linked list through the objects using this got */
356 bfd *in_got_link_next;
358 /* For every got, this is a link to the next got subsegment. */
361 /* For every got, this is the section. */
364 /* For every got, this is it's total number of *entries*. */
365 int total_got_entries;
367 /* For every got, this is the sum of the number of *entries* required
368 to hold all of the member object's local got. */
369 int n_local_got_entries;
372 #define alpha_elf_tdata(abfd) \
373 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
376 elf64_alpha_mkobject (abfd)
379 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
380 abfd->tdata.any = bfd_zalloc (abfd, amt);
381 if (abfd->tdata.any == NULL)
387 elf64_alpha_object_p (abfd)
390 /* Allocate our special target data. */
391 struct alpha_elf_obj_tdata *new_tdata;
392 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
393 new_tdata = bfd_zalloc (abfd, amt);
394 if (new_tdata == NULL)
396 new_tdata->root = *abfd->tdata.elf_obj_data;
397 abfd->tdata.any = new_tdata;
399 /* Set the right machine number for an Alpha ELF file. */
400 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
403 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
404 from smaller values. Start with zero, widen, *then* decrement. */
405 #define MINUS_ONE (((bfd_vma)0) - 1)
407 #define SKIP_HOWTO(N) \
408 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
410 static reloc_howto_type elf64_alpha_howto_table[] =
412 HOWTO (R_ALPHA_NONE, /* type */
414 0, /* size (0 = byte, 1 = short, 2 = long) */
416 true, /* pc_relative */
418 complain_overflow_dont, /* complain_on_overflow */
419 elf64_alpha_reloc_nil, /* special_function */
421 false, /* partial_inplace */
424 true), /* pcrel_offset */
426 /* A 32 bit reference to a symbol. */
427 HOWTO (R_ALPHA_REFLONG, /* type */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
431 false, /* pc_relative */
433 complain_overflow_bitfield, /* complain_on_overflow */
434 0, /* special_function */
435 "REFLONG", /* name */
436 false, /* partial_inplace */
437 0xffffffff, /* src_mask */
438 0xffffffff, /* dst_mask */
439 false), /* pcrel_offset */
441 /* A 64 bit reference to a symbol. */
442 HOWTO (R_ALPHA_REFQUAD, /* type */
444 4, /* size (0 = byte, 1 = short, 2 = long) */
446 false, /* pc_relative */
448 complain_overflow_bitfield, /* complain_on_overflow */
449 0, /* special_function */
450 "REFQUAD", /* name */
451 false, /* partial_inplace */
452 MINUS_ONE, /* src_mask */
453 MINUS_ONE, /* dst_mask */
454 false), /* pcrel_offset */
456 /* A 32 bit GP relative offset. This is just like REFLONG except
457 that when the value is used the value of the gp register will be
459 HOWTO (R_ALPHA_GPREL32, /* type */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
463 false, /* pc_relative */
465 complain_overflow_bitfield, /* complain_on_overflow */
466 0, /* special_function */
467 "GPREL32", /* name */
468 false, /* partial_inplace */
469 0xffffffff, /* src_mask */
470 0xffffffff, /* dst_mask */
471 false), /* pcrel_offset */
473 /* Used for an instruction that refers to memory off the GP register. */
474 HOWTO (R_ALPHA_LITERAL, /* type */
476 1, /* size (0 = byte, 1 = short, 2 = long) */
478 false, /* pc_relative */
480 complain_overflow_signed, /* complain_on_overflow */
481 0, /* special_function */
482 "ELF_LITERAL", /* name */
483 false, /* partial_inplace */
484 0xffff, /* src_mask */
485 0xffff, /* dst_mask */
486 false), /* pcrel_offset */
488 /* This reloc only appears immediately following an ELF_LITERAL reloc.
489 It identifies a use of the literal. The symbol index is special:
490 1 means the literal address is in the base register of a memory
491 format instruction; 2 means the literal address is in the byte
492 offset register of a byte-manipulation instruction; 3 means the
493 literal address is in the target register of a jsr instruction.
494 This does not actually do any relocation. */
495 HOWTO (R_ALPHA_LITUSE, /* type */
497 1, /* size (0 = byte, 1 = short, 2 = long) */
499 false, /* pc_relative */
501 complain_overflow_dont, /* complain_on_overflow */
502 elf64_alpha_reloc_nil, /* special_function */
504 false, /* partial_inplace */
507 false), /* pcrel_offset */
509 /* Load the gp register. This is always used for a ldah instruction
510 which loads the upper 16 bits of the gp register. The symbol
511 index of the GPDISP instruction is an offset in bytes to the lda
512 instruction that loads the lower 16 bits. The value to use for
513 the relocation is the difference between the GP value and the
514 current location; the load will always be done against a register
515 holding the current address.
517 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
518 any offset is present in the instructions, it is an offset from
519 the register to the ldah instruction. This lets us avoid any
520 stupid hackery like inventing a gp value to do partial relocation
521 against. Also unlike ECOFF, we do the whole relocation off of
522 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
523 space consuming bit, that, since all the information was present
524 in the GPDISP_HI16 reloc. */
525 HOWTO (R_ALPHA_GPDISP, /* type */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
529 false, /* pc_relative */
531 complain_overflow_dont, /* complain_on_overflow */
532 elf64_alpha_reloc_gpdisp, /* special_function */
534 false, /* partial_inplace */
535 0xffff, /* src_mask */
536 0xffff, /* dst_mask */
537 true), /* pcrel_offset */
539 /* A 21 bit branch. */
540 HOWTO (R_ALPHA_BRADDR, /* type */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
544 true, /* pc_relative */
546 complain_overflow_signed, /* complain_on_overflow */
547 0, /* special_function */
549 false, /* partial_inplace */
550 0x1fffff, /* src_mask */
551 0x1fffff, /* dst_mask */
552 true), /* pcrel_offset */
554 /* A hint for a jump to a register. */
555 HOWTO (R_ALPHA_HINT, /* type */
557 1, /* size (0 = byte, 1 = short, 2 = long) */
559 true, /* pc_relative */
561 complain_overflow_dont, /* complain_on_overflow */
562 0, /* special_function */
564 false, /* partial_inplace */
565 0x3fff, /* src_mask */
566 0x3fff, /* dst_mask */
567 true), /* pcrel_offset */
569 /* 16 bit PC relative offset. */
570 HOWTO (R_ALPHA_SREL16, /* type */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
574 true, /* pc_relative */
576 complain_overflow_signed, /* complain_on_overflow */
577 0, /* special_function */
579 false, /* partial_inplace */
580 0xffff, /* src_mask */
581 0xffff, /* dst_mask */
582 true), /* pcrel_offset */
584 /* 32 bit PC relative offset. */
585 HOWTO (R_ALPHA_SREL32, /* type */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
589 true, /* pc_relative */
591 complain_overflow_signed, /* complain_on_overflow */
592 0, /* special_function */
594 false, /* partial_inplace */
595 0xffffffff, /* src_mask */
596 0xffffffff, /* dst_mask */
597 true), /* pcrel_offset */
599 /* A 64 bit PC relative offset. */
600 HOWTO (R_ALPHA_SREL64, /* type */
602 4, /* size (0 = byte, 1 = short, 2 = long) */
604 true, /* pc_relative */
606 complain_overflow_signed, /* complain_on_overflow */
607 0, /* special_function */
609 false, /* partial_inplace */
610 MINUS_ONE, /* src_mask */
611 MINUS_ONE, /* dst_mask */
612 true), /* pcrel_offset */
614 /* Skip 12 - 16; deprecated ECOFF relocs. */
621 /* The high 16 bits of the displacement from GP to the target. */
622 HOWTO (R_ALPHA_GPRELHIGH,
624 1, /* size (0 = byte, 1 = short, 2 = long) */
626 false, /* pc_relative */
628 complain_overflow_signed, /* complain_on_overflow */
629 0, /* special_function */
630 "GPRELHIGH", /* name */
631 false, /* partial_inplace */
632 0xffff, /* src_mask */
633 0xffff, /* dst_mask */
634 false), /* pcrel_offset */
636 /* The low 16 bits of the displacement from GP to the target. */
637 HOWTO (R_ALPHA_GPRELLOW,
639 1, /* size (0 = byte, 1 = short, 2 = long) */
641 false, /* pc_relative */
643 complain_overflow_dont, /* complain_on_overflow */
644 0, /* special_function */
645 "GPRELLOW", /* name */
646 false, /* partial_inplace */
647 0xffff, /* src_mask */
648 0xffff, /* dst_mask */
649 false), /* pcrel_offset */
651 /* A 16-bit displacement from the GP to the target. */
652 HOWTO (R_ALPHA_GPREL16,
654 1, /* size (0 = byte, 1 = short, 2 = long) */
656 false, /* pc_relative */
658 complain_overflow_signed, /* complain_on_overflow */
659 0, /* special_function */
660 "GPREL16", /* name */
661 false, /* partial_inplace */
662 0xffff, /* src_mask */
663 0xffff, /* dst_mask */
664 false), /* pcrel_offset */
666 /* Skip 20 - 23; deprecated ECOFF relocs. */
672 /* Misc ELF relocations. */
674 /* A dynamic relocation to copy the target into our .dynbss section. */
675 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
676 is present because every other ELF has one, but should not be used
677 because .dynbss is an ugly thing. */
684 complain_overflow_dont,
685 bfd_elf_generic_reloc,
692 /* A dynamic relocation for a .got entry. */
693 HOWTO (R_ALPHA_GLOB_DAT,
699 complain_overflow_dont,
700 bfd_elf_generic_reloc,
707 /* A dynamic relocation for a .plt entry. */
708 HOWTO (R_ALPHA_JMP_SLOT,
714 complain_overflow_dont,
715 bfd_elf_generic_reloc,
722 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
723 HOWTO (R_ALPHA_RELATIVE,
729 complain_overflow_dont,
730 bfd_elf_generic_reloc,
737 /* A 21 bit branch that adjusts for gp loads. */
738 HOWTO (R_ALPHA_BRSGP, /* type */
740 2, /* size (0 = byte, 1 = short, 2 = long) */
742 true, /* pc_relative */
744 complain_overflow_signed, /* complain_on_overflow */
745 0, /* special_function */
747 false, /* partial_inplace */
748 0x1fffff, /* src_mask */
749 0x1fffff, /* dst_mask */
750 true), /* pcrel_offset */
753 /* A relocation function which doesn't do anything. */
755 static bfd_reloc_status_type
756 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
757 bfd *abfd ATTRIBUTE_UNUSED;
759 asymbol *sym ATTRIBUTE_UNUSED;
760 PTR data ATTRIBUTE_UNUSED;
763 char **error_message ATTRIBUTE_UNUSED;
766 reloc->address += sec->output_offset;
770 /* A relocation function used for an unsupported reloc. */
772 static bfd_reloc_status_type
773 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
774 bfd *abfd ATTRIBUTE_UNUSED;
776 asymbol *sym ATTRIBUTE_UNUSED;
777 PTR data ATTRIBUTE_UNUSED;
780 char **error_message ATTRIBUTE_UNUSED;
783 reloc->address += sec->output_offset;
784 return bfd_reloc_notsupported;
787 /* Do the work of the GPDISP relocation. */
789 static bfd_reloc_status_type
790 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
796 bfd_reloc_status_type ret = bfd_reloc_ok;
798 unsigned long i_ldah, i_lda;
800 i_ldah = bfd_get_32 (abfd, p_ldah);
801 i_lda = bfd_get_32 (abfd, p_lda);
803 /* Complain if the instructions are not correct. */
804 if (((i_ldah >> 26) & 0x3f) != 0x09
805 || ((i_lda >> 26) & 0x3f) != 0x08)
806 ret = bfd_reloc_dangerous;
808 /* Extract the user-supplied offset, mirroring the sign extensions
809 that the instructions perform. */
810 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
811 addend = (addend ^ 0x80008000) - 0x80008000;
815 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
816 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
817 ret = bfd_reloc_overflow;
819 /* compensate for the sign extension again. */
820 i_ldah = ((i_ldah & 0xffff0000)
821 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
822 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
824 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
825 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
830 /* The special function for the GPDISP reloc. */
832 static bfd_reloc_status_type
833 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
836 arelent *reloc_entry;
837 asymbol *sym ATTRIBUTE_UNUSED;
839 asection *input_section;
843 bfd_reloc_status_type ret;
844 bfd_vma gp, relocation;
845 bfd_byte *p_ldah, *p_lda;
847 /* Don't do anything if we're not doing a final link. */
850 reloc_entry->address += input_section->output_offset;
854 if (reloc_entry->address > input_section->_cooked_size ||
855 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
856 return bfd_reloc_outofrange;
858 /* The gp used in the portion of the output object to which this
859 input object belongs is cached on the input bfd. */
860 gp = _bfd_get_gp_value (abfd);
862 relocation = (input_section->output_section->vma
863 + input_section->output_offset
864 + reloc_entry->address);
866 p_ldah = (bfd_byte *) data + reloc_entry->address;
867 p_lda = p_ldah + reloc_entry->addend;
869 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
871 /* Complain if the instructions are not correct. */
872 if (ret == bfd_reloc_dangerous)
873 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
878 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
882 bfd_reloc_code_real_type bfd_reloc_val;
886 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
888 {BFD_RELOC_NONE, R_ALPHA_NONE},
889 {BFD_RELOC_32, R_ALPHA_REFLONG},
890 {BFD_RELOC_64, R_ALPHA_REFQUAD},
891 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
892 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
893 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
894 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
895 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
896 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
897 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
898 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
899 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
900 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
901 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
902 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
903 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
904 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
907 /* Given a BFD reloc type, return a HOWTO structure. */
909 static reloc_howto_type *
910 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
911 bfd *abfd ATTRIBUTE_UNUSED;
912 bfd_reloc_code_real_type code;
914 const struct elf_reloc_map *i, *e;
915 i = e = elf64_alpha_reloc_map;
916 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
919 if (i->bfd_reloc_val == code)
920 return &elf64_alpha_howto_table[i->elf_reloc_val];
925 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
928 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
929 bfd *abfd ATTRIBUTE_UNUSED;
931 Elf64_Internal_Rela *dst;
935 r_type = ELF64_R_TYPE(dst->r_info);
936 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
937 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
940 /* These functions do relaxation for Alpha ELF.
942 Currently I'm only handling what I can do with existing compiler
943 and assembler support, which means no instructions are removed,
944 though some may be nopped. At this time GCC does not emit enough
945 information to do all of the relaxing that is possible. It will
946 take some not small amount of work for that to happen.
948 There are a couple of interesting papers that I once read on this
949 subject, that I cannot find references to at the moment, that
950 related to Alpha in particular. They are by David Wall, then of
955 #define INSN_JSR 0x68004000
956 #define INSN_JSR_MASK 0xfc00c000
960 #define INSN_UNOP 0x2ffe0000
962 struct alpha_relax_info
967 Elf_Internal_Rela *relocs, *relend;
968 struct bfd_link_info *link_info;
969 boolean changed_contents;
970 boolean changed_relocs;
974 struct alpha_elf_link_hash_entry *h;
975 struct alpha_elf_got_entry *gotent;
979 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
980 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
981 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
983 static boolean elf64_alpha_relax_without_lituse
984 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
985 Elf_Internal_Rela *irel));
987 static bfd_vma elf64_alpha_relax_opt_call
988 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
990 static boolean elf64_alpha_relax_section
991 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
994 static Elf_Internal_Rela *
995 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
996 Elf_Internal_Rela *rel, *relend;
1000 while (rel < relend)
1002 if (rel->r_offset == offset
1003 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
1010 static Elf_Internal_Rela *
1011 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1012 struct alpha_relax_info *info;
1014 Elf_Internal_Rela *irel, *irelend;
1016 Elf_Internal_Rela *urel;
1017 int flags, count, i;
1018 bfd_signed_vma disp;
1021 boolean lit_reused = false;
1022 boolean all_optimized = true;
1023 unsigned int lit_insn;
1025 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1026 if (lit_insn >> 26 != OP_LDQ)
1028 ((*_bfd_error_handler)
1029 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1030 bfd_archive_filename (info->abfd), info->sec->name,
1031 (unsigned long) irel->r_offset));
1035 /* Summarize how this particular LITERAL is used. */
1036 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1038 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1040 if (urel->r_addend <= 3)
1041 flags |= 1 << urel->r_addend;
1044 /* A little preparation for the loop... */
1045 disp = symval - info->gp;
1047 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1051 bfd_signed_vma xdisp;
1053 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1055 switch (urel->r_addend)
1057 default: /* 0 = ADDRESS FORMAT */
1058 /* This type is really just a placeholder to note that all
1059 uses cannot be optimized, but to still allow some. */
1060 all_optimized = false;
1063 case 1: /* MEM FORMAT */
1064 /* We can always optimize 16-bit displacements. */
1066 /* Extract the displacement from the instruction, sign-extending
1067 it if necessary, then test whether it is within 16 or 32 bits
1068 displacement from GP. */
1069 insn_disp = insn & 0x0000ffff;
1070 if (insn_disp & 0x00008000)
1071 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1073 xdisp = disp + insn_disp;
1074 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1075 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1079 /* Take the op code and dest from this insn, take the base
1080 register from the literal insn. Leave the offset alone. */
1081 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1082 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1084 urel->r_addend = irel->r_addend;
1085 info->changed_relocs = true;
1087 bfd_put_32 (info->abfd, (bfd_vma) insn,
1088 info->contents + urel->r_offset);
1089 info->changed_contents = true;
1092 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1093 else if (fits32 && !(flags & ~6))
1095 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1097 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1099 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1100 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1101 info->contents + irel->r_offset);
1103 info->changed_contents = true;
1105 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1107 urel->r_addend = irel->r_addend;
1108 info->changed_relocs = true;
1111 all_optimized = false;
1114 case 2: /* BYTE OFFSET FORMAT */
1115 /* We can always optimize byte instructions. */
1117 /* FIXME: sanity check the insn for byte op. Check that the
1118 literal dest reg is indeed Rb in the byte insn. */
1120 insn &= ~ (unsigned) 0x001ff000;
1121 insn |= ((symval & 7) << 13) | 0x1000;
1123 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1125 info->changed_relocs = true;
1127 bfd_put_32 (info->abfd, (bfd_vma) insn,
1128 info->contents + urel->r_offset);
1129 info->changed_contents = true;
1132 case 3: /* CALL FORMAT */
1134 /* If not zero, place to jump without needing pv. */
1135 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1136 bfd_vma org = (info->sec->output_section->vma
1137 + info->sec->output_offset
1138 + urel->r_offset + 4);
1139 bfd_signed_vma odisp;
1141 odisp = (optdest ? optdest : symval) - org;
1142 if (odisp >= -0x400000 && odisp < 0x400000)
1144 Elf_Internal_Rela *xrel;
1146 /* Preserve branch prediction call stack when possible. */
1147 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1148 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1150 insn = (OP_BR << 26) | (insn & 0x03e00000);
1152 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1154 urel->r_addend = irel->r_addend;
1157 urel->r_addend += optdest - symval;
1159 all_optimized = false;
1161 bfd_put_32 (info->abfd, (bfd_vma) insn,
1162 info->contents + urel->r_offset);
1164 /* Kill any HINT reloc that might exist for this insn. */
1165 xrel = (elf64_alpha_find_reloc_at_ofs
1166 (info->relocs, info->relend, urel->r_offset,
1169 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1171 info->changed_contents = true;
1172 info->changed_relocs = true;
1175 all_optimized = false;
1177 /* Even if the target is not in range for a direct branch,
1178 if we share a GP, we can eliminate the gp reload. */
1181 Elf_Internal_Rela *gpdisp
1182 = (elf64_alpha_find_reloc_at_ofs
1183 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1186 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1187 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1188 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1189 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1191 /* Verify that the instruction is "ldah $29,0($26)".
1192 Consider a function that ends in a noreturn call,
1193 and that the next function begins with an ldgp,
1194 and that by accident there is no padding between.
1195 In that case the insn would use $27 as the base. */
1196 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1198 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1199 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1201 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1202 info->changed_contents = true;
1203 info->changed_relocs = true;
1212 /* If all cases were optimized, we can reduce the use count on this
1213 got entry by one, possibly eliminating it. */
1216 info->gotent->use_count -= 1;
1217 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1219 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1221 /* If the literal instruction is no longer needed (it may have been
1222 reused. We can eliminate it.
1223 ??? For now, I don't want to deal with compacting the section,
1224 so just nop it out. */
1227 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1228 info->changed_relocs = true;
1230 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1231 info->contents + irel->r_offset);
1232 info->changed_contents = true;
1236 return irel + count;
1240 elf64_alpha_relax_opt_call (info, symval)
1241 struct alpha_relax_info *info;
1244 /* If the function has the same gp, and we can identify that the
1245 function does not use its function pointer, we can eliminate the
1248 /* If the symbol is marked NOPV, we are being told the function never
1249 needs its procedure value. */
1250 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1253 /* If the symbol is marked STD_GP, we are being told the function does
1254 a normal ldgp in the first two words. */
1255 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1258 /* Otherwise, we may be able to identify a GP load in the first two
1259 words, which we can then skip. */
1262 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1265 /* Load the relocations from the section that the target symbol is in. */
1266 if (info->sec == info->tsec)
1268 tsec_relocs = info->relocs;
1269 tsec_relend = info->relend;
1274 tsec_relocs = (_bfd_elf64_link_read_relocs
1275 (info->abfd, info->tsec, (PTR) NULL,
1276 (Elf_Internal_Rela *) NULL,
1277 info->link_info->keep_memory));
1278 if (tsec_relocs == NULL)
1280 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1281 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1284 /* Recover the symbol's offset within the section. */
1285 ofs = (symval - info->tsec->output_section->vma
1286 - info->tsec->output_offset);
1288 /* Look for a GPDISP reloc. */
1289 gpdisp = (elf64_alpha_find_reloc_at_ofs
1290 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1292 if (!gpdisp || gpdisp->r_addend != 4)
1302 /* We've now determined that we can skip an initial gp load. Verify
1303 that the call and the target use the same gp. */
1304 if (info->link_info->hash->creator != info->tsec->owner->xvec
1305 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1312 elf64_alpha_relax_without_lituse (info, symval, irel)
1313 struct alpha_relax_info *info;
1315 Elf_Internal_Rela *irel;
1318 bfd_signed_vma disp;
1320 /* Get the instruction. */
1321 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1323 if (insn >> 26 != OP_LDQ)
1325 ((*_bfd_error_handler)
1326 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1327 bfd_archive_filename (info->abfd), info->sec->name,
1328 (unsigned long) irel->r_offset));
1332 /* So we aren't told much. Do what we can with the address load and
1333 fake the rest. All of the optimizations here require that the
1334 offset from the GP fit in 16 bits. */
1336 disp = symval - info->gp;
1337 if (disp < -0x8000 || disp >= 0x8000)
1340 /* On the LITERAL instruction itself, consider exchanging
1341 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1343 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1344 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1345 info->changed_contents = true;
1347 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1348 info->changed_relocs = true;
1350 /* Reduce the use count on this got entry by one, possibly
1352 info->gotent->use_count -= 1;
1353 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1355 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1357 /* ??? Search forward through this basic block looking for insns
1358 that use the target register. Stop after an insn modifying the
1359 register is seen, or after a branch or call.
1361 Any such memory load insn may be substituted by a load directly
1362 off the GP. This allows the memory load insn to be issued before
1363 the calculated GP register would otherwise be ready.
1365 Any such jsr insn can be replaced by a bsr if it is in range.
1367 This would mean that we'd have to _add_ relocations, the pain of
1368 which gives one pause. */
1374 elf64_alpha_relax_section (abfd, sec, link_info, again)
1377 struct bfd_link_info *link_info;
1380 Elf_Internal_Shdr *symtab_hdr;
1381 Elf_Internal_Shdr *shndx_hdr;
1382 Elf_Internal_Rela *internal_relocs;
1383 Elf_Internal_Rela *free_relocs = NULL;
1384 Elf_Internal_Rela *irel, *irelend;
1385 bfd_byte *free_contents = NULL;
1386 Elf64_External_Sym *extsyms = NULL;
1387 Elf64_External_Sym *free_extsyms = NULL;
1388 Elf_External_Sym_Shndx *shndx_buf = NULL;
1389 struct alpha_elf_got_entry **local_got_entries;
1390 struct alpha_relax_info info;
1392 /* We are not currently changing any sizes, so only one pass. */
1395 if (link_info->relocateable
1396 || (sec->flags & SEC_RELOC) == 0
1397 || sec->reloc_count == 0)
1400 /* If this is the first time we have been called for this section,
1401 initialize the cooked size. */
1402 if (sec->_cooked_size == 0)
1403 sec->_cooked_size = sec->_raw_size;
1405 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1406 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1408 /* Load the relocations for this section. */
1409 internal_relocs = (_bfd_elf64_link_read_relocs
1410 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1411 link_info->keep_memory));
1412 if (internal_relocs == NULL)
1414 if (! link_info->keep_memory)
1415 free_relocs = internal_relocs;
1417 memset(&info, 0, sizeof (info));
1420 info.link_info = link_info;
1421 info.relocs = internal_relocs;
1422 info.relend = irelend = internal_relocs + sec->reloc_count;
1424 /* Find the GP for this object. */
1425 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1428 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1429 info.gp = _bfd_get_gp_value (info.gotobj);
1432 info.gp = (sgot->output_section->vma
1433 + sgot->output_offset
1435 _bfd_set_gp_value (info.gotobj, info.gp);
1439 for (irel = internal_relocs; irel < irelend; irel++)
1442 Elf_Internal_Sym isym;
1443 struct alpha_elf_got_entry *gotent;
1445 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1448 /* Get the section contents. */
1449 if (info.contents == NULL)
1451 if (elf_section_data (sec)->this_hdr.contents != NULL)
1452 info.contents = elf_section_data (sec)->this_hdr.contents;
1455 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1456 if (info.contents == NULL)
1458 free_contents = info.contents;
1460 if (! bfd_get_section_contents (abfd, sec, info.contents,
1461 (file_ptr) 0, sec->_raw_size))
1466 /* Read this BFD's symbols if we haven't done so already. */
1467 if (extsyms == NULL)
1471 if (symtab_hdr->contents != NULL)
1472 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1475 amt = symtab_hdr->sh_info;
1476 amt *= sizeof (Elf64_External_Sym);
1477 extsyms = (Elf64_External_Sym *) bfd_malloc (amt);
1478 if (extsyms == NULL)
1480 free_extsyms = extsyms;
1481 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1482 || bfd_bread ((PTR) extsyms, amt, abfd) != amt)
1486 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1487 if (shndx_hdr->sh_size != 0)
1489 amt = symtab_hdr->sh_info;
1490 amt *= sizeof (Elf_External_Sym_Shndx);
1491 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1492 if (shndx_buf == NULL)
1494 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1495 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1500 /* Get the value of the symbol referred to by the reloc. */
1501 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1503 /* A local symbol. */
1504 Elf64_External_Sym *esym;
1505 Elf_External_Sym_Shndx *shndx;
1507 esym = extsyms + ELF64_R_SYM (irel->r_info);
1508 shndx = shndx_buf + (shndx_buf ? ELF64_R_SYM (irel->r_info) : 0);
1509 bfd_elf64_swap_symbol_in (abfd, esym, shndx, &isym);
1510 if (isym.st_shndx == SHN_UNDEF)
1511 info.tsec = bfd_und_section_ptr;
1512 else if (isym.st_shndx == SHN_ABS)
1513 info.tsec = bfd_abs_section_ptr;
1514 else if (isym.st_shndx == SHN_COMMON)
1515 info.tsec = bfd_com_section_ptr;
1517 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1520 info.other = isym.st_other;
1521 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1522 symval = isym.st_value;
1527 struct alpha_elf_link_hash_entry *h;
1529 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1530 h = alpha_elf_sym_hashes (abfd)[indx];
1531 BFD_ASSERT (h != NULL);
1533 while (h->root.root.type == bfd_link_hash_indirect
1534 || h->root.root.type == bfd_link_hash_warning)
1535 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1537 /* We can't do anthing with undefined or dynamic symbols. */
1538 if (h->root.root.type == bfd_link_hash_undefined
1539 || h->root.root.type == bfd_link_hash_undefweak
1540 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1544 info.tsec = h->root.root.u.def.section;
1545 info.other = h->root.other;
1546 gotent = h->got_entries;
1547 symval = h->root.root.u.def.value;
1550 /* Search for the got entry to be used by this relocation. */
1551 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1552 gotent = gotent->next;
1553 info.gotent = gotent;
1555 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1556 symval += irel->r_addend;
1558 BFD_ASSERT(info.gotent != NULL);
1560 /* If there exist LITUSE relocations immediately following, this
1561 opens up all sorts of interesting optimizations, because we
1562 now know every location that this address load is used. */
1564 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1566 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1572 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1577 if (!elf64_alpha_size_got_sections (abfd, link_info))
1580 if (info.changed_relocs)
1582 elf_section_data (sec)->relocs = internal_relocs;
1584 else if (free_relocs != NULL)
1589 if (info.changed_contents)
1591 elf_section_data (sec)->this_hdr.contents = info.contents;
1593 else if (free_contents != NULL)
1595 if (! link_info->keep_memory)
1596 free (free_contents);
1599 /* Cache the section contents for elf_link_input_bfd. */
1600 elf_section_data (sec)->this_hdr.contents = info.contents;
1604 if (shndx_buf != NULL)
1607 if (free_extsyms != NULL)
1609 if (! link_info->keep_memory)
1610 free (free_extsyms);
1613 /* Cache the symbols for elf_link_input_bfd. */
1614 symtab_hdr->contents = (unsigned char *) extsyms;
1618 *again = info.changed_contents || info.changed_relocs;
1623 if (free_relocs != NULL)
1625 if (free_contents != NULL)
1626 free (free_contents);
1627 if (shndx_buf != NULL)
1629 if (free_extsyms != NULL)
1630 free (free_extsyms);
1635 #define PLT_HEADER_SIZE 32
1636 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1637 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1638 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1639 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
1641 #define PLT_ENTRY_SIZE 12
1642 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1643 #define PLT_ENTRY_WORD2 0
1644 #define PLT_ENTRY_WORD3 0
1646 #define MAX_GOT_ENTRIES (64*1024 / 8)
1648 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1650 /* Handle an Alpha specific section when reading an object file. This
1651 is called when elfcode.h finds a section with an unknown type.
1652 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1656 elf64_alpha_section_from_shdr (abfd, hdr, name)
1658 Elf64_Internal_Shdr *hdr;
1663 /* There ought to be a place to keep ELF backend specific flags, but
1664 at the moment there isn't one. We just keep track of the
1665 sections by their name, instead. Fortunately, the ABI gives
1666 suggested names for all the MIPS specific sections, so we will
1667 probably get away with this. */
1668 switch (hdr->sh_type)
1670 case SHT_ALPHA_DEBUG:
1671 if (strcmp (name, ".mdebug") != 0)
1678 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1680 newsect = hdr->bfd_section;
1682 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1684 if (! bfd_set_section_flags (abfd, newsect,
1685 (bfd_get_section_flags (abfd, newsect)
1693 /* Convert Alpha specific section flags to bfd internal section flags. */
1696 elf64_alpha_section_flags (flags, hdr)
1698 Elf64_Internal_Shdr *hdr;
1700 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1701 *flags |= SEC_SMALL_DATA;
1706 /* Set the correct type for an Alpha ELF section. We do this by the
1707 section name, which is a hack, but ought to work. */
1710 elf64_alpha_fake_sections (abfd, hdr, sec)
1712 Elf64_Internal_Shdr *hdr;
1715 register const char *name;
1717 name = bfd_get_section_name (abfd, sec);
1719 if (strcmp (name, ".mdebug") == 0)
1721 hdr->sh_type = SHT_ALPHA_DEBUG;
1722 /* In a shared object on Irix 5.3, the .mdebug section has an
1723 entsize of 0. FIXME: Does this matter? */
1724 if ((abfd->flags & DYNAMIC) != 0 )
1725 hdr->sh_entsize = 0;
1727 hdr->sh_entsize = 1;
1729 else if ((sec->flags & SEC_SMALL_DATA)
1730 || strcmp (name, ".sdata") == 0
1731 || strcmp (name, ".sbss") == 0
1732 || strcmp (name, ".lit4") == 0
1733 || strcmp (name, ".lit8") == 0)
1734 hdr->sh_flags |= SHF_ALPHA_GPREL;
1739 /* Hook called by the linker routine which adds symbols from an object
1740 file. We use it to put .comm items in .sbss, and not .bss. */
1743 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1745 struct bfd_link_info *info;
1746 const Elf_Internal_Sym *sym;
1747 const char **namep ATTRIBUTE_UNUSED;
1748 flagword *flagsp ATTRIBUTE_UNUSED;
1752 if (sym->st_shndx == SHN_COMMON
1753 && !info->relocateable
1754 && sym->st_size <= elf_gp_size (abfd))
1756 /* Common symbols less than or equal to -G nn bytes are
1757 automatically put into .sbss. */
1759 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1763 scomm = bfd_make_section (abfd, ".scommon");
1765 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1767 | SEC_LINKER_CREATED)))
1772 *valp = sym->st_size;
1778 /* Create the .got section. */
1781 elf64_alpha_create_got_section(abfd, info)
1783 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1787 if (bfd_get_section_by_name (abfd, ".got"))
1790 s = bfd_make_section (abfd, ".got");
1792 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1795 | SEC_LINKER_CREATED))
1796 || !bfd_set_section_alignment (abfd, s, 3))
1799 alpha_elf_tdata (abfd)->got = s;
1804 /* Create all the dynamic sections. */
1807 elf64_alpha_create_dynamic_sections (abfd, info)
1809 struct bfd_link_info *info;
1812 struct elf_link_hash_entry *h;
1814 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1816 s = bfd_make_section (abfd, ".plt");
1818 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1821 | SEC_LINKER_CREATED
1823 || ! bfd_set_section_alignment (abfd, s, 3))
1826 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1829 if (! (_bfd_generic_link_add_one_symbol
1830 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1831 (bfd_vma) 0, (const char *) NULL, false,
1832 get_elf_backend_data (abfd)->collect,
1833 (struct bfd_link_hash_entry **) &h)))
1835 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1836 h->type = STT_OBJECT;
1839 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1842 s = bfd_make_section (abfd, ".rela.plt");
1844 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1847 | SEC_LINKER_CREATED
1849 || ! bfd_set_section_alignment (abfd, s, 3))
1852 /* We may or may not have created a .got section for this object, but
1853 we definitely havn't done the rest of the work. */
1855 if (!elf64_alpha_create_got_section (abfd, info))
1858 s = bfd_make_section(abfd, ".rela.got");
1860 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1863 | SEC_LINKER_CREATED
1865 || !bfd_set_section_alignment (abfd, s, 3))
1868 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1869 dynobj's .got section. We don't do this in the linker script
1870 because we don't want to define the symbol if we are not creating
1871 a global offset table. */
1873 if (!(_bfd_generic_link_add_one_symbol
1874 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1875 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1876 false, get_elf_backend_data (abfd)->collect,
1877 (struct bfd_link_hash_entry **) &h)))
1879 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1880 h->type = STT_OBJECT;
1883 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1886 elf_hash_table (info)->hgot = h;
1891 /* Read ECOFF debugging information from a .mdebug section into a
1892 ecoff_debug_info structure. */
1895 elf64_alpha_read_ecoff_info (abfd, section, debug)
1898 struct ecoff_debug_info *debug;
1901 const struct ecoff_debug_swap *swap;
1902 char *ext_hdr = NULL;
1904 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1905 memset (debug, 0, sizeof (*debug));
1907 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1908 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1911 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1912 swap->external_hdr_size)
1916 symhdr = &debug->symbolic_header;
1917 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1919 /* The symbolic header contains absolute file offsets and sizes to
1921 #define READ(ptr, offset, count, size, type) \
1922 if (symhdr->count == 0) \
1923 debug->ptr = NULL; \
1926 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1927 debug->ptr = (type) bfd_malloc (amt); \
1928 if (debug->ptr == NULL) \
1929 goto error_return; \
1930 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1931 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1932 goto error_return; \
1935 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1936 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1937 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1938 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1939 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1940 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1942 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1943 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1944 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1945 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1946 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1950 debug->adjust = NULL;
1955 if (ext_hdr != NULL)
1957 if (debug->line != NULL)
1959 if (debug->external_dnr != NULL)
1960 free (debug->external_dnr);
1961 if (debug->external_pdr != NULL)
1962 free (debug->external_pdr);
1963 if (debug->external_sym != NULL)
1964 free (debug->external_sym);
1965 if (debug->external_opt != NULL)
1966 free (debug->external_opt);
1967 if (debug->external_aux != NULL)
1968 free (debug->external_aux);
1969 if (debug->ss != NULL)
1971 if (debug->ssext != NULL)
1972 free (debug->ssext);
1973 if (debug->external_fdr != NULL)
1974 free (debug->external_fdr);
1975 if (debug->external_rfd != NULL)
1976 free (debug->external_rfd);
1977 if (debug->external_ext != NULL)
1978 free (debug->external_ext);
1982 /* Alpha ELF local labels start with '$'. */
1985 elf64_alpha_is_local_label_name (abfd, name)
1986 bfd *abfd ATTRIBUTE_UNUSED;
1989 return name[0] == '$';
1992 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1993 routine in order to handle the ECOFF debugging information. We
1994 still call this mips_elf_find_line because of the slot
1995 find_line_info in elf_obj_tdata is declared that way. */
1997 struct mips_elf_find_line
1999 struct ecoff_debug_info d;
2000 struct ecoff_find_line i;
2004 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2005 functionname_ptr, line_ptr)
2010 const char **filename_ptr;
2011 const char **functionname_ptr;
2012 unsigned int *line_ptr;
2016 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2017 filename_ptr, functionname_ptr,
2019 &elf_tdata (abfd)->dwarf2_find_line_info))
2022 msec = bfd_get_section_by_name (abfd, ".mdebug");
2026 struct mips_elf_find_line *fi;
2027 const struct ecoff_debug_swap * const swap =
2028 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2030 /* If we are called during a link, alpha_elf_final_link may have
2031 cleared the SEC_HAS_CONTENTS field. We force it back on here
2032 if appropriate (which it normally will be). */
2033 origflags = msec->flags;
2034 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2035 msec->flags |= SEC_HAS_CONTENTS;
2037 fi = elf_tdata (abfd)->find_line_info;
2040 bfd_size_type external_fdr_size;
2043 struct fdr *fdr_ptr;
2044 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2046 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2049 msec->flags = origflags;
2053 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2055 msec->flags = origflags;
2059 /* Swap in the FDR information. */
2060 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2061 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2062 if (fi->d.fdr == NULL)
2064 msec->flags = origflags;
2067 external_fdr_size = swap->external_fdr_size;
2068 fdr_ptr = fi->d.fdr;
2069 fraw_src = (char *) fi->d.external_fdr;
2070 fraw_end = (fraw_src
2071 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2072 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2073 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2075 elf_tdata (abfd)->find_line_info = fi;
2077 /* Note that we don't bother to ever free this information.
2078 find_nearest_line is either called all the time, as in
2079 objdump -l, so the information should be saved, or it is
2080 rarely called, as in ld error messages, so the memory
2081 wasted is unimportant. Still, it would probably be a
2082 good idea for free_cached_info to throw it away. */
2085 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2086 &fi->i, filename_ptr, functionname_ptr,
2089 msec->flags = origflags;
2093 msec->flags = origflags;
2096 /* Fall back on the generic ELF find_nearest_line routine. */
2098 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2099 filename_ptr, functionname_ptr,
2103 /* Structure used to pass information to alpha_elf_output_extsym. */
2108 struct bfd_link_info *info;
2109 struct ecoff_debug_info *debug;
2110 const struct ecoff_debug_swap *swap;
2115 elf64_alpha_output_extsym (h, data)
2116 struct alpha_elf_link_hash_entry *h;
2119 struct extsym_info *einfo = (struct extsym_info *) data;
2121 asection *sec, *output_section;
2123 if (h->root.root.type == bfd_link_hash_warning)
2124 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2126 if (h->root.indx == -2)
2128 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2129 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2130 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2131 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2133 else if (einfo->info->strip == strip_all
2134 || (einfo->info->strip == strip_some
2135 && bfd_hash_lookup (einfo->info->keep_hash,
2136 h->root.root.root.string,
2137 false, false) == NULL))
2145 if (h->esym.ifd == -2)
2148 h->esym.cobol_main = 0;
2149 h->esym.weakext = 0;
2150 h->esym.reserved = 0;
2151 h->esym.ifd = ifdNil;
2152 h->esym.asym.value = 0;
2153 h->esym.asym.st = stGlobal;
2155 if (h->root.root.type != bfd_link_hash_defined
2156 && h->root.root.type != bfd_link_hash_defweak)
2157 h->esym.asym.sc = scAbs;
2162 sec = h->root.root.u.def.section;
2163 output_section = sec->output_section;
2165 /* When making a shared library and symbol h is the one from
2166 the another shared library, OUTPUT_SECTION may be null. */
2167 if (output_section == NULL)
2168 h->esym.asym.sc = scUndefined;
2171 name = bfd_section_name (output_section->owner, output_section);
2173 if (strcmp (name, ".text") == 0)
2174 h->esym.asym.sc = scText;
2175 else if (strcmp (name, ".data") == 0)
2176 h->esym.asym.sc = scData;
2177 else if (strcmp (name, ".sdata") == 0)
2178 h->esym.asym.sc = scSData;
2179 else if (strcmp (name, ".rodata") == 0
2180 || strcmp (name, ".rdata") == 0)
2181 h->esym.asym.sc = scRData;
2182 else if (strcmp (name, ".bss") == 0)
2183 h->esym.asym.sc = scBss;
2184 else if (strcmp (name, ".sbss") == 0)
2185 h->esym.asym.sc = scSBss;
2186 else if (strcmp (name, ".init") == 0)
2187 h->esym.asym.sc = scInit;
2188 else if (strcmp (name, ".fini") == 0)
2189 h->esym.asym.sc = scFini;
2191 h->esym.asym.sc = scAbs;
2195 h->esym.asym.reserved = 0;
2196 h->esym.asym.index = indexNil;
2199 if (h->root.root.type == bfd_link_hash_common)
2200 h->esym.asym.value = h->root.root.u.c.size;
2201 else if (h->root.root.type == bfd_link_hash_defined
2202 || h->root.root.type == bfd_link_hash_defweak)
2204 if (h->esym.asym.sc == scCommon)
2205 h->esym.asym.sc = scBss;
2206 else if (h->esym.asym.sc == scSCommon)
2207 h->esym.asym.sc = scSBss;
2209 sec = h->root.root.u.def.section;
2210 output_section = sec->output_section;
2211 if (output_section != NULL)
2212 h->esym.asym.value = (h->root.root.u.def.value
2213 + sec->output_offset
2214 + output_section->vma);
2216 h->esym.asym.value = 0;
2218 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2220 /* Set type and value for a symbol with a function stub. */
2221 h->esym.asym.st = stProc;
2222 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2224 h->esym.asym.value = 0;
2227 output_section = sec->output_section;
2228 if (output_section != NULL)
2229 h->esym.asym.value = (h->root.plt.offset
2230 + sec->output_offset
2231 + output_section->vma);
2233 h->esym.asym.value = 0;
2237 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2238 h->root.root.root.string,
2241 einfo->failed = true;
2248 /* FIXME: Create a runtime procedure table from the .mdebug section.
2251 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2254 struct bfd_link_info *info;
2256 struct ecoff_debug_info *debug;
2259 /* Handle dynamic relocations when doing an Alpha ELF link. */
2262 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2264 struct bfd_link_info *info;
2266 const Elf_Internal_Rela *relocs;
2270 const char *rel_sec_name;
2271 Elf_Internal_Shdr *symtab_hdr;
2272 struct alpha_elf_link_hash_entry **sym_hashes;
2273 struct alpha_elf_got_entry **local_got_entries;
2274 const Elf_Internal_Rela *rel, *relend;
2278 if (info->relocateable)
2281 dynobj = elf_hash_table(info)->dynobj;
2283 elf_hash_table(info)->dynobj = dynobj = abfd;
2286 rel_sec_name = NULL;
2287 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2288 sym_hashes = alpha_elf_sym_hashes(abfd);
2289 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2292 relend = relocs + sec->reloc_count;
2293 for (rel = relocs; rel < relend; ++rel)
2295 unsigned long r_symndx, r_type;
2296 struct alpha_elf_link_hash_entry *h;
2298 r_symndx = ELF64_R_SYM (rel->r_info);
2299 if (r_symndx < symtab_hdr->sh_info)
2303 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2305 while (h->root.root.type == bfd_link_hash_indirect
2306 || h->root.root.type == bfd_link_hash_warning)
2307 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2309 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2311 r_type = ELF64_R_TYPE (rel->r_info);
2315 case R_ALPHA_LITERAL:
2317 struct alpha_elf_got_entry *gotent;
2322 /* Search for and possibly create a got entry. */
2323 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2324 if (gotent->gotobj == abfd &&
2325 gotent->addend == rel->r_addend)
2330 amt = sizeof (struct alpha_elf_got_entry);
2331 gotent = ((struct alpha_elf_got_entry *)
2332 bfd_alloc (abfd, amt));
2336 gotent->gotobj = abfd;
2337 gotent->addend = rel->r_addend;
2338 gotent->got_offset = -1;
2340 gotent->use_count = 1;
2342 gotent->next = h->got_entries;
2343 h->got_entries = gotent;
2345 alpha_elf_tdata (abfd)->total_got_entries++;
2348 gotent->use_count += 1;
2352 /* This is a local .got entry -- record for merge. */
2353 if (!local_got_entries)
2356 size = symtab_hdr->sh_info;
2357 size *= sizeof (struct alpha_elf_got_entry *);
2359 local_got_entries = ((struct alpha_elf_got_entry **)
2360 bfd_alloc (abfd, size));
2361 if (!local_got_entries)
2364 memset (local_got_entries, 0, (size_t) size);
2365 alpha_elf_tdata (abfd)->local_got_entries =
2369 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2370 gotent != NULL && gotent->addend != rel->r_addend;
2371 gotent = gotent->next)
2375 amt = sizeof (struct alpha_elf_got_entry);
2376 gotent = ((struct alpha_elf_got_entry *)
2377 bfd_alloc (abfd, amt));
2381 gotent->gotobj = abfd;
2382 gotent->addend = rel->r_addend;
2383 gotent->got_offset = -1;
2385 gotent->use_count = 1;
2387 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2388 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2390 alpha_elf_tdata(abfd)->total_got_entries++;
2391 alpha_elf_tdata(abfd)->n_local_got_entries++;
2394 gotent->use_count += 1;
2397 /* Remember how this literal is used from its LITUSEs.
2398 This will be important when it comes to decide if we can
2399 create a .plt entry for a function symbol. */
2401 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2406 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2407 flags |= 1 << rel->r_addend;
2409 while (rel+1 < relend &&
2410 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2414 /* No LITUSEs -- presumably the address is not being
2415 loaded for nothing. */
2416 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2419 gotent->flags |= flags;
2422 /* Make a guess as to whether a .plt entry will be needed. */
2423 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2424 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2426 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2431 case R_ALPHA_GPDISP:
2432 case R_ALPHA_GPREL16:
2433 case R_ALPHA_GPREL32:
2434 case R_ALPHA_GPRELHIGH:
2435 case R_ALPHA_GPRELLOW:
2437 /* We don't actually use the .got here, but the sections must
2438 be created before the linker maps input sections to output
2442 if (!elf64_alpha_create_got_section (abfd, info))
2445 /* Make sure the object's gotobj is set to itself so
2446 that we default to every object with its own .got.
2447 We'll merge .gots later once we've collected each
2449 alpha_elf_tdata(abfd)->gotobj = abfd;
2455 case R_ALPHA_SREL16:
2456 case R_ALPHA_SREL32:
2457 case R_ALPHA_SREL64:
2462 case R_ALPHA_REFLONG:
2463 case R_ALPHA_REFQUAD:
2464 if (rel_sec_name == NULL)
2466 rel_sec_name = (bfd_elf_string_from_elf_section
2467 (abfd, elf_elfheader(abfd)->e_shstrndx,
2468 elf_section_data(sec)->rel_hdr.sh_name));
2469 if (rel_sec_name == NULL)
2472 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2473 && strcmp (bfd_get_section_name (abfd, sec),
2474 rel_sec_name+5) == 0);
2477 /* We need to create the section here now whether we eventually
2478 use it or not so that it gets mapped to an output section by
2479 the linker. If not used, we'll kill it in
2480 size_dynamic_sections. */
2483 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2488 sreloc = bfd_make_section (dynobj, rel_sec_name);
2489 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2490 | SEC_LINKER_CREATED | SEC_READONLY);
2491 if (sec->flags & SEC_ALLOC)
2492 flags |= SEC_ALLOC | SEC_LOAD;
2494 || !bfd_set_section_flags (dynobj, sreloc, flags)
2495 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2502 /* Since we havn't seen all of the input symbols yet, we
2503 don't know whether we'll actually need a dynamic relocation
2504 entry for this reloc. So make a record of it. Once we
2505 find out if this thing needs dynamic relocation we'll
2506 expand the relocation sections by the appropriate amount. */
2508 struct alpha_elf_reloc_entry *rent;
2510 for (rent = h->reloc_entries; rent; rent = rent->next)
2511 if (rent->rtype == r_type && rent->srel == sreloc)
2516 amt = sizeof (struct alpha_elf_reloc_entry);
2517 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
2521 rent->srel = sreloc;
2522 rent->rtype = r_type;
2524 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
2525 == (SEC_READONLY | SEC_ALLOC));
2527 rent->next = h->reloc_entries;
2528 h->reloc_entries = rent;
2533 else if (info->shared && (sec->flags & SEC_ALLOC))
2535 /* If this is a shared library, and the section is to be
2536 loaded into memory, we need a RELATIVE reloc. */
2537 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2538 if (sec->flags & SEC_READONLY)
2539 info->flags |= DF_TEXTREL;
2548 /* Adjust a symbol defined by a dynamic object and referenced by a
2549 regular object. The current definition is in some section of the
2550 dynamic object, but we're not including those sections. We have to
2551 change the definition to something the rest of the link can
2555 elf64_alpha_adjust_dynamic_symbol (info, h)
2556 struct bfd_link_info *info;
2557 struct elf_link_hash_entry *h;
2561 struct alpha_elf_link_hash_entry *ah;
2563 dynobj = elf_hash_table(info)->dynobj;
2564 ah = (struct alpha_elf_link_hash_entry *)h;
2566 /* Now that we've seen all of the input symbols, finalize our decision
2567 about whether this symbol should get a .plt entry. */
2569 if (alpha_elf_dynamic_symbol_p (h, info)
2570 && ((h->type == STT_FUNC
2571 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2572 || (h->type == STT_NOTYPE
2573 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2574 /* Don't prevent otherwise valid programs from linking by attempting
2575 to create a new .got entry somewhere. A Correct Solution would be
2576 to add a new .got section to a new object file and let it be merged
2577 somewhere later. But for now don't bother. */
2580 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2582 s = bfd_get_section_by_name(dynobj, ".plt");
2583 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2586 /* The first bit of the .plt is reserved. */
2587 if (s->_raw_size == 0)
2588 s->_raw_size = PLT_HEADER_SIZE;
2590 h->plt.offset = s->_raw_size;
2591 s->_raw_size += PLT_ENTRY_SIZE;
2593 /* If this symbol is not defined in a regular file, and we are not
2594 generating a shared library, then set the symbol to the location
2595 in the .plt. This is required to make function pointers compare
2596 equal between the normal executable and the shared library. */
2598 && h->root.type != bfd_link_hash_defweak)
2600 h->root.u.def.section = s;
2601 h->root.u.def.value = h->plt.offset;
2604 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2605 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2606 BFD_ASSERT (s != NULL);
2607 s->_raw_size += sizeof (Elf64_External_Rela);
2612 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2614 /* If this is a weak symbol, and there is a real definition, the
2615 processor independent code will have arranged for us to see the
2616 real definition first, and we can just use the same value. */
2617 if (h->weakdef != NULL)
2619 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2620 || h->weakdef->root.type == bfd_link_hash_defweak);
2621 h->root.u.def.section = h->weakdef->root.u.def.section;
2622 h->root.u.def.value = h->weakdef->root.u.def.value;
2626 /* This is a reference to a symbol defined by a dynamic object which
2627 is not a function. The Alpha, since it uses .got entries for all
2628 symbols even in regular objects, does not need the hackery of a
2629 .dynbss section and COPY dynamic relocations. */
2634 /* Symbol versioning can create new symbols, and make our old symbols
2635 indirect to the new ones. Consolidate the got and reloc information
2636 in these situations. */
2639 elf64_alpha_merge_ind_symbols (hi, dummy)
2640 struct alpha_elf_link_hash_entry *hi;
2641 PTR dummy ATTRIBUTE_UNUSED;
2643 struct alpha_elf_link_hash_entry *hs;
2645 if (hi->root.root.type != bfd_link_hash_indirect)
2649 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2650 } while (hs->root.root.type == bfd_link_hash_indirect);
2652 /* Merge the flags. Whee. */
2654 hs->flags |= hi->flags;
2656 /* Merge the .got entries. Cannibalize the old symbol's list in
2657 doing so, since we don't need it anymore. */
2659 if (hs->got_entries == NULL)
2660 hs->got_entries = hi->got_entries;
2663 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2665 gsh = hs->got_entries;
2666 for (gi = hi->got_entries; gi ; gi = gin)
2669 for (gs = gsh; gs ; gs = gs->next)
2670 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2672 gi->next = hs->got_entries;
2673 hs->got_entries = gi;
2677 hi->got_entries = NULL;
2679 /* And similar for the reloc entries. */
2681 if (hs->reloc_entries == NULL)
2682 hs->reloc_entries = hi->reloc_entries;
2685 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2687 rsh = hs->reloc_entries;
2688 for (ri = hi->reloc_entries; ri ; ri = rin)
2691 for (rs = rsh; rs ; rs = rs->next)
2692 if (ri->rtype == rs->rtype)
2694 rs->count += ri->count;
2697 ri->next = hs->reloc_entries;
2698 hs->reloc_entries = ri;
2702 hi->reloc_entries = NULL;
2707 /* Is it possible to merge two object file's .got tables? */
2710 elf64_alpha_can_merge_gots (a, b)
2713 int total = alpha_elf_tdata (a)->total_got_entries;
2716 /* Trivial quick fallout test. */
2717 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2720 /* By their nature, local .got entries cannot be merged. */
2721 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2724 /* Failing the common trivial comparison, we must effectively
2725 perform the merge. Not actually performing the merge means that
2726 we don't have to store undo information in case we fail. */
2727 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2729 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2730 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2733 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2734 for (i = 0; i < n; ++i)
2736 struct alpha_elf_got_entry *ae, *be;
2737 struct alpha_elf_link_hash_entry *h;
2740 while (h->root.root.type == bfd_link_hash_indirect
2741 || h->root.root.type == bfd_link_hash_warning)
2742 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2744 for (be = h->got_entries; be ; be = be->next)
2746 if (be->use_count == 0)
2748 if (be->gotobj != b)
2751 for (ae = h->got_entries; ae ; ae = ae->next)
2752 if (ae->gotobj == a && ae->addend == be->addend)
2755 if (++total > MAX_GOT_ENTRIES)
2765 /* Actually merge two .got tables. */
2768 elf64_alpha_merge_gots (a, b)
2771 int total = alpha_elf_tdata (a)->total_got_entries;
2774 /* Remember local expansion. */
2776 int e = alpha_elf_tdata (b)->n_local_got_entries;
2778 alpha_elf_tdata (a)->n_local_got_entries += e;
2781 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2783 struct alpha_elf_got_entry **local_got_entries;
2784 struct alpha_elf_link_hash_entry **hashes;
2785 Elf_Internal_Shdr *symtab_hdr;
2788 /* Let the local .got entries know they are part of a new subsegment. */
2789 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2790 if (local_got_entries)
2792 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2793 for (i = 0; i < n; ++i)
2795 struct alpha_elf_got_entry *ent;
2796 for (ent = local_got_entries[i]; ent; ent = ent->next)
2801 /* Merge the global .got entries. */
2802 hashes = alpha_elf_sym_hashes (bsub);
2803 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2805 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2806 for (i = 0; i < n; ++i)
2808 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2809 struct alpha_elf_link_hash_entry *h;
2812 while (h->root.root.type == bfd_link_hash_indirect
2813 || h->root.root.type == bfd_link_hash_warning)
2814 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2816 start = &h->got_entries;
2817 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2819 if (be->use_count == 0)
2824 if (be->gotobj != b)
2827 for (ae = *start; ae ; ae = ae->next)
2828 if (ae->gotobj == a && ae->addend == be->addend)
2830 ae->flags |= be->flags;
2831 ae->use_count += be->use_count;
2842 alpha_elf_tdata (bsub)->gotobj = a;
2844 alpha_elf_tdata (a)->total_got_entries = total;
2846 /* Merge the two in_got chains. */
2851 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2854 alpha_elf_tdata (bsub)->in_got_link_next = b;
2858 /* Calculate the offsets for the got entries. */
2861 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2862 struct alpha_elf_link_hash_entry *h;
2863 PTR arg ATTRIBUTE_UNUSED;
2865 struct alpha_elf_got_entry *gotent;
2867 if (h->root.root.type == bfd_link_hash_warning)
2868 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2870 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2871 if (gotent->use_count > 0)
2874 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2876 gotent->got_offset = *plge;
2884 elf64_alpha_calc_got_offsets (info)
2885 struct bfd_link_info *info;
2887 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2889 /* First, zero out the .got sizes, as we may be recalculating the
2890 .got after optimizing it. */
2891 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2892 alpha_elf_tdata(i)->got->_raw_size = 0;
2894 /* Next, fill in the offsets for all the global entries. */
2895 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2896 elf64_alpha_calc_got_offsets_for_symbol,
2899 /* Finally, fill in the offsets for the local entries. */
2900 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2902 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2905 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2907 struct alpha_elf_got_entry **local_got_entries, *gotent;
2910 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2911 if (!local_got_entries)
2914 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2915 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2916 if (gotent->use_count > 0)
2918 gotent->got_offset = got_offset;
2923 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2924 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2928 /* Constructs the gots. */
2931 elf64_alpha_size_got_sections (output_bfd, info)
2932 bfd *output_bfd ATTRIBUTE_UNUSED;
2933 struct bfd_link_info *info;
2935 bfd *i, *got_list, *cur_got_obj = NULL;
2936 int something_changed = 0;
2938 got_list = alpha_elf_hash_table (info)->got_list;
2940 /* On the first time through, pretend we have an existing got list
2941 consisting of all of the input files. */
2942 if (got_list == NULL)
2944 for (i = info->input_bfds; i ; i = i->link_next)
2946 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2947 if (this_got == NULL)
2950 /* We are assuming no merging has yet ocurred. */
2951 BFD_ASSERT (this_got == i);
2953 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2955 /* Yikes! A single object file has too many entries. */
2956 (*_bfd_error_handler)
2957 (_("%s: .got subsegment exceeds 64K (size %d)"),
2958 bfd_archive_filename (i),
2959 alpha_elf_tdata (this_got)->total_got_entries * 8);
2963 if (got_list == NULL)
2964 got_list = this_got;
2966 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2967 cur_got_obj = this_got;
2970 /* Strange degenerate case of no got references. */
2971 if (got_list == NULL)
2974 alpha_elf_hash_table (info)->got_list = got_list;
2976 /* Force got offsets to be recalculated. */
2977 something_changed = 1;
2980 cur_got_obj = got_list;
2981 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2984 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2986 elf64_alpha_merge_gots (cur_got_obj, i);
2987 i = alpha_elf_tdata(i)->got_link_next;
2988 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2989 something_changed = 1;
2994 i = alpha_elf_tdata(i)->got_link_next;
2998 /* Once the gots have been merged, fill in the got offsets for
2999 everything therein. */
3000 if (1 || something_changed)
3001 elf64_alpha_calc_got_offsets (info);
3007 elf64_alpha_always_size_sections (output_bfd, info)
3009 struct bfd_link_info *info;
3013 if (info->relocateable)
3016 /* First, take care of the indirect symbols created by versioning. */
3017 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3018 elf64_alpha_merge_ind_symbols,
3021 if (!elf64_alpha_size_got_sections (output_bfd, info))
3024 /* Allocate space for all of the .got subsections. */
3025 i = alpha_elf_hash_table (info)->got_list;
3026 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3028 asection *s = alpha_elf_tdata(i)->got;
3029 if (s->_raw_size > 0)
3031 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3032 if (s->contents == NULL)
3040 /* Work out the sizes of the dynamic relocation entries. */
3043 elf64_alpha_calc_dynrel_sizes (h, info)
3044 struct alpha_elf_link_hash_entry *h;
3045 struct bfd_link_info *info;
3047 if (h->root.root.type == bfd_link_hash_warning)
3048 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3050 /* If the symbol was defined as a common symbol in a regular object
3051 file, and there was no definition in any dynamic object, then the
3052 linker will have allocated space for the symbol in a common
3053 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3054 set. This is done for dynamic symbols in
3055 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3056 symbols, somehow. */
3057 if (((h->root.elf_link_hash_flags
3058 & (ELF_LINK_HASH_DEF_REGULAR
3059 | ELF_LINK_HASH_REF_REGULAR
3060 | ELF_LINK_HASH_DEF_DYNAMIC))
3061 == ELF_LINK_HASH_REF_REGULAR)
3062 && (h->root.root.type == bfd_link_hash_defined
3063 || h->root.root.type == bfd_link_hash_defweak)
3064 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3066 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3069 /* If the symbol is dynamic, we'll need all the relocations in their
3070 natural form. If this is a shared object, and it has been forced
3071 local, we'll need the same number of RELATIVE relocations. */
3073 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3075 struct alpha_elf_reloc_entry *relent;
3077 struct alpha_elf_got_entry *gotent;
3078 bfd_size_type count;
3081 for (relent = h->reloc_entries; relent; relent = relent->next)
3082 if (relent->rtype == R_ALPHA_REFLONG
3083 || relent->rtype == R_ALPHA_REFQUAD)
3085 relent->srel->_raw_size +=
3086 sizeof (Elf64_External_Rela) * relent->count;
3087 if (relent->reltext)
3088 info->flags |= DT_TEXTREL;
3091 dynobj = elf_hash_table(info)->dynobj;
3094 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3097 /* If we are using a .plt entry, subtract one, as the first
3098 reference uses a .rela.plt entry instead. */
3099 if (h->root.plt.offset != MINUS_ONE)
3104 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3105 BFD_ASSERT (srel != NULL);
3106 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3113 /* Set the sizes of the dynamic sections. */
3116 elf64_alpha_size_dynamic_sections (output_bfd, info)
3117 bfd *output_bfd ATTRIBUTE_UNUSED;
3118 struct bfd_link_info *info;
3124 dynobj = elf_hash_table(info)->dynobj;
3125 BFD_ASSERT(dynobj != NULL);
3127 if (elf_hash_table (info)->dynamic_sections_created)
3129 /* Set the contents of the .interp section to the interpreter. */
3132 s = bfd_get_section_by_name (dynobj, ".interp");
3133 BFD_ASSERT (s != NULL);
3134 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3135 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3138 /* Now that we've seen all of the input files, we can decide which
3139 symbols need dynamic relocation entries and which don't. We've
3140 collected information in check_relocs that we can now apply to
3141 size the dynamic relocation sections. */
3142 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3143 elf64_alpha_calc_dynrel_sizes,
3146 /* When building shared libraries, each local .got entry needs a
3152 bfd_size_type count;
3154 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3155 BFD_ASSERT (srel != NULL);
3157 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3159 i = alpha_elf_tdata(i)->got_link_next)
3160 count += alpha_elf_tdata(i)->n_local_got_entries;
3162 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3165 /* else we're not dynamic and by definition we don't need such things. */
3167 /* The check_relocs and adjust_dynamic_symbol entry points have
3168 determined the sizes of the various dynamic sections. Allocate
3171 for (s = dynobj->sections; s != NULL; s = s->next)
3176 if (!(s->flags & SEC_LINKER_CREATED))
3179 /* It's OK to base decisions on the section name, because none
3180 of the dynobj section names depend upon the input files. */
3181 name = bfd_get_section_name (dynobj, s);
3183 /* If we don't need this section, strip it from the output file.
3184 This is to handle .rela.bss and .rela.plt. We must create it
3185 in create_dynamic_sections, because it must be created before
3186 the linker maps input sections to output sections. The
3187 linker does that before adjust_dynamic_symbol is called, and
3188 it is that function which decides whether anything needs to
3189 go into these sections. */
3193 if (strncmp (name, ".rela", 5) == 0)
3195 strip = (s->_raw_size == 0);
3199 if (strcmp(name, ".rela.plt") == 0)
3202 /* We use the reloc_count field as a counter if we need
3203 to copy relocs into the output file. */
3207 else if (strcmp (name, ".plt") != 0)
3209 /* It's not one of our dynamic sections, so don't allocate space. */
3214 _bfd_strip_section_from_output (info, s);
3217 /* Allocate memory for the section contents. */
3218 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3219 if (s->contents == NULL && s->_raw_size != 0)
3224 if (elf_hash_table (info)->dynamic_sections_created)
3226 /* Add some entries to the .dynamic section. We fill in the
3227 values later, in elf64_alpha_finish_dynamic_sections, but we
3228 must add the entries now so that we get the correct size for
3229 the .dynamic section. The DT_DEBUG entry is filled in by the
3230 dynamic linker and used by the debugger. */
3231 #define add_dynamic_entry(TAG, VAL) \
3232 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3236 if (!add_dynamic_entry (DT_DEBUG, 0))
3240 if (!add_dynamic_entry (DT_PLTGOT, 0))
3245 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3246 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3247 || !add_dynamic_entry (DT_JMPREL, 0))
3251 if (!add_dynamic_entry (DT_RELA, 0)
3252 || !add_dynamic_entry (DT_RELASZ, 0)
3253 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3256 if (info->flags & DF_TEXTREL)
3258 if (!add_dynamic_entry (DT_TEXTREL, 0))
3262 #undef add_dynamic_entry
3267 /* Relocate an Alpha ELF section. */
3270 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3271 contents, relocs, local_syms, local_sections)
3273 struct bfd_link_info *info;
3275 asection *input_section;
3277 Elf_Internal_Rela *relocs;
3278 Elf_Internal_Sym *local_syms;
3279 asection **local_sections;
3281 Elf_Internal_Shdr *symtab_hdr;
3282 Elf_Internal_Rela *rel;
3283 Elf_Internal_Rela *relend;
3284 asection *sec, *sgot, *srel, *srelgot;
3285 bfd *dynobj, *gotobj;
3287 boolean ret_val = true;
3289 srelgot = srel = NULL;
3290 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3291 dynobj = elf_hash_table (info)->dynobj;
3294 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3297 /* Find the gp value for this input bfd. */
3300 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3303 sgot = alpha_elf_tdata (gotobj)->got;
3304 gp = _bfd_get_gp_value (gotobj);
3307 gp = (sgot->output_section->vma
3308 + sgot->output_offset
3310 _bfd_set_gp_value (gotobj, gp);
3315 relend = relocs + input_section->reloc_count;
3316 for (; rel < relend; rel++)
3319 reloc_howto_type *howto;
3320 unsigned long r_symndx;
3321 struct alpha_elf_link_hash_entry *h;
3322 Elf_Internal_Sym *sym;
3325 bfd_reloc_status_type r;
3327 r_type = ELF64_R_TYPE(rel->r_info);
3328 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3330 bfd_set_error (bfd_error_bad_value);
3333 howto = elf64_alpha_howto_table + r_type;
3335 r_symndx = ELF64_R_SYM(rel->r_info);
3337 if (info->relocateable)
3339 /* This is a relocateable link. We don't have to change
3340 anything, unless the reloc is against a section symbol,
3341 in which case we have to adjust according to where the
3342 section symbol winds up in the output section. */
3344 /* The symbol associated with GPDISP and LITUSE is
3345 immaterial. Only the addend is significant. */
3346 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3349 if (r_symndx < symtab_hdr->sh_info)
3351 sym = local_syms + r_symndx;
3352 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3354 sec = local_sections[r_symndx];
3355 rel->r_addend += sec->output_offset + sym->st_value;
3362 /* This is a final link. */
3368 if (r_symndx < symtab_hdr->sh_info)
3370 sym = local_syms + r_symndx;
3371 sec = local_sections[r_symndx];
3372 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3376 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3378 while (h->root.root.type == bfd_link_hash_indirect
3379 || h->root.root.type == bfd_link_hash_warning)
3380 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3382 if (h->root.root.type == bfd_link_hash_defined
3383 || h->root.root.type == bfd_link_hash_defweak)
3385 sec = h->root.root.u.def.section;
3387 if (sec->output_section == NULL)
3391 relocation = (h->root.root.u.def.value
3392 + sec->output_section->vma
3393 + sec->output_offset);
3396 else if (h->root.root.type == bfd_link_hash_undefweak)
3398 else if (info->shared
3399 && (!info->symbolic || info->allow_shlib_undefined)
3400 && !info->no_undefined
3401 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3405 if (!((*info->callbacks->undefined_symbol)
3406 (info, h->root.root.root.string, input_bfd,
3407 input_section, rel->r_offset,
3408 (!info->shared || info->no_undefined
3409 || ELF_ST_VISIBILITY (h->root.other)))))
3414 addend = rel->r_addend;
3418 case R_ALPHA_GPDISP:
3420 bfd_byte *p_ldah, *p_lda;
3422 BFD_ASSERT(gp != 0);
3424 relocation = (input_section->output_section->vma
3425 + input_section->output_offset
3428 p_ldah = contents + rel->r_offset - input_section->vma;
3429 p_lda = p_ldah + rel->r_addend;
3431 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3436 case R_ALPHA_LITERAL:
3438 struct alpha_elf_got_entry *gotent;
3439 boolean dynamic_symbol;
3441 BFD_ASSERT(sgot != NULL);
3442 BFD_ASSERT(gp != 0);
3446 gotent = h->got_entries;
3447 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3451 gotent = (alpha_elf_tdata(input_bfd)->
3452 local_got_entries[r_symndx]);
3453 dynamic_symbol = false;
3455 /* Need to adjust local GOT entries' addends for SEC_MERGE
3456 unless it has been done already. */
3457 if ((sec->flags & SEC_MERGE)
3458 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3459 && (elf_section_data (sec)->sec_info_type
3460 == ELF_INFO_TYPE_MERGE)
3461 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3463 struct alpha_elf_got_entry *ent;
3466 for (ent = gotent; ent; ent = ent->next)
3468 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3469 if (ent->use_count == 0)
3473 _bfd_merged_section_offset (output_bfd, &msec,
3474 elf_section_data (sec)->
3479 ent->addend -= sym->st_value;
3480 ent->addend += msec->output_section->vma
3481 + msec->output_offset
3482 - sec->output_section->vma
3483 - sec->output_offset;
3488 BFD_ASSERT(gotent != NULL);
3490 while (gotent->gotobj != gotobj || gotent->addend != addend)
3491 gotent = gotent->next;
3493 BFD_ASSERT(gotent->use_count >= 1);
3495 /* Initialize the .got entry's value. */
3496 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3498 bfd_put_64 (output_bfd, relocation + addend,
3499 sgot->contents + gotent->got_offset);
3501 /* If the symbol has been forced local, output a
3502 RELATIVE reloc, otherwise it will be handled in
3503 finish_dynamic_symbol. */
3504 if (info->shared && !dynamic_symbol)
3506 Elf_Internal_Rela outrel;
3508 BFD_ASSERT(srelgot != NULL);
3510 outrel.r_offset = (sgot->output_section->vma
3511 + sgot->output_offset
3512 + gotent->got_offset);
3513 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3514 outrel.r_addend = relocation + addend;
3516 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3517 ((Elf64_External_Rela *)
3519 + srelgot->reloc_count++);
3520 BFD_ASSERT (sizeof (Elf64_External_Rela)
3521 * srelgot->reloc_count
3522 <= srelgot->_cooked_size);
3525 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3528 /* Figure the gprel relocation. */
3530 relocation = (sgot->output_section->vma
3531 + sgot->output_offset
3532 + gotent->got_offset);
3535 /* overflow handled by _bfd_final_link_relocate */
3538 case R_ALPHA_GPREL16:
3539 case R_ALPHA_GPREL32:
3540 case R_ALPHA_GPRELLOW:
3541 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3543 (*_bfd_error_handler)
3544 (_("%s: gp-relative relocation against dynamic symbol %s"),
3545 bfd_archive_filename (input_bfd), h->root.root.root.string);
3548 BFD_ASSERT(gp != 0);
3552 case R_ALPHA_GPRELHIGH:
3553 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3555 (*_bfd_error_handler)
3556 (_("%s: gp-relative relocation against dynamic symbol %s"),
3557 bfd_archive_filename (input_bfd), h->root.root.root.string);
3560 BFD_ASSERT(gp != 0);
3562 relocation += addend;
3564 relocation = (((bfd_signed_vma) relocation >> 16)
3565 + ((relocation >> 15) & 1));
3569 /* A call to a dynamic symbol is definitely out of range of
3570 the 16-bit displacement. Don't bother writing anything. */
3571 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3578 case R_ALPHA_BRADDR:
3579 /* The regular PC-relative stuff measures from the start of
3580 the instruction rather than the end. */
3589 /* The regular PC-relative stuff measures from the start of
3590 the instruction rather than the end. */
3593 /* The source and destination gp must be the same. Note that
3594 the source will always have an assigned gp, since we forced
3595 one in check_relocs, but that the destination may not, as
3596 it might not have had any relocations at all. Also take
3597 care not to crash if H is an undefined symbol. */
3598 if (h != NULL && sec != NULL
3599 && alpha_elf_tdata (sec->owner)->gotobj
3600 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
3602 (*_bfd_error_handler)
3603 (_("%s: change in gp: BRSGP %s"),
3604 bfd_archive_filename (input_bfd), h->root.root.root.string);
3608 /* The symbol should be marked either NOPV or STD_GPLOAD. */
3610 other = h->root.other;
3612 other = sym->st_other;
3613 switch (other & STO_ALPHA_STD_GPLOAD)
3615 case STO_ALPHA_NOPV:
3617 case STO_ALPHA_STD_GPLOAD:
3622 name = h->root.root.root.string;
3625 name = (bfd_elf_string_from_elf_section
3626 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3628 name = _("<unknown>");
3629 else if (name[0] == 0)
3630 name = bfd_section_name (input_bfd, sec);
3632 (*_bfd_error_handler)
3633 (_("%s: !samegp reloc against symbol without .prologue: %s"),
3634 bfd_archive_filename (input_bfd), name);
3642 case R_ALPHA_REFLONG:
3643 case R_ALPHA_REFQUAD:
3645 Elf_Internal_Rela outrel;
3647 /* Careful here to remember RELATIVE relocations for global
3648 variables for symbolic shared objects. */
3650 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3652 BFD_ASSERT(h->root.dynindx != -1);
3653 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3654 outrel.r_addend = addend;
3655 addend = 0, relocation = 0;
3657 else if (info->shared
3659 && (input_section->flags & SEC_ALLOC))
3661 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3662 outrel.r_addend = relocation + addend;
3671 name = (bfd_elf_string_from_elf_section
3672 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3673 elf_section_data(input_section)->rel_hdr.sh_name));
3674 BFD_ASSERT(name != NULL);
3676 srel = bfd_get_section_by_name (dynobj, name);
3677 BFD_ASSERT(srel != NULL);
3681 _bfd_elf_section_offset (output_bfd, info, input_section,
3683 if ((outrel.r_offset | 1) != (bfd_vma) -1)
3684 outrel.r_offset += (input_section->output_section->vma
3685 + input_section->output_offset);
3687 memset (&outrel, 0, sizeof outrel);
3689 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3690 ((Elf64_External_Rela *)
3692 + srel->reloc_count++);
3693 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3694 <= srel->_cooked_size);
3698 case R_ALPHA_SREL32:
3699 case R_ALPHA_SREL64:
3700 /* ??? .eh_frame references to discarded sections will be smashed
3701 to relocations against SHN_UNDEF. The .eh_frame format allows
3702 NULL to be encoded as 0 in any format, so this works here. */
3704 howto = (elf64_alpha_howto_table
3705 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
3710 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3711 contents, rel->r_offset, relocation,
3721 case bfd_reloc_overflow:
3725 /* Don't warn if the overflow is due to pc relative reloc
3726 against discarded section. Section optimization code should
3729 if (r_symndx < symtab_hdr->sh_info
3730 && sec != NULL && howto->pc_relative
3731 && elf_discarded_section (sec))
3735 name = h->root.root.root.string;
3738 name = (bfd_elf_string_from_elf_section
3739 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3743 name = bfd_section_name (input_bfd, sec);
3745 if (! ((*info->callbacks->reloc_overflow)
3746 (info, name, howto->name, (bfd_vma) 0,
3747 input_bfd, input_section, rel->r_offset)))
3753 case bfd_reloc_outofrange:
3761 /* Finish up dynamic symbol handling. We set the contents of various
3762 dynamic sections here. */
3765 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3767 struct bfd_link_info *info;
3768 struct elf_link_hash_entry *h;
3769 Elf_Internal_Sym *sym;
3771 bfd *dynobj = elf_hash_table(info)->dynobj;
3773 if (h->plt.offset != MINUS_ONE)
3775 /* Fill in the .plt entry for this symbol. */
3776 asection *splt, *sgot, *srel;
3777 Elf_Internal_Rela outrel;
3778 bfd_vma got_addr, plt_addr;
3780 struct alpha_elf_got_entry *gotent;
3782 BFD_ASSERT (h->dynindx != -1);
3784 /* The first .got entry will be updated by the .plt with the
3785 address of the target function. */
3786 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3787 BFD_ASSERT (gotent && gotent->addend == 0);
3789 splt = bfd_get_section_by_name (dynobj, ".plt");
3790 BFD_ASSERT (splt != NULL);
3791 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3792 BFD_ASSERT (srel != NULL);
3793 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3794 BFD_ASSERT (sgot != NULL);
3796 got_addr = (sgot->output_section->vma
3797 + sgot->output_offset
3798 + gotent->got_offset);
3799 plt_addr = (splt->output_section->vma
3800 + splt->output_offset
3803 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3805 /* Fill in the entry in the procedure linkage table. */
3807 bfd_vma insn1, insn2, insn3;
3809 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3810 insn2 = PLT_ENTRY_WORD2;
3811 insn3 = PLT_ENTRY_WORD3;
3813 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3814 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3815 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3818 /* Fill in the entry in the .rela.plt section. */
3819 outrel.r_offset = got_addr;
3820 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3821 outrel.r_addend = 0;
3823 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3824 ((Elf64_External_Rela *)srel->contents
3827 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3829 /* Mark the symbol as undefined, rather than as defined in the
3830 .plt section. Leave the value alone. */
3831 sym->st_shndx = SHN_UNDEF;
3834 /* Fill in the entries in the .got. */
3835 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3837 /* Subsequent .got entries will continue to bounce through the .plt. */
3840 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3841 BFD_ASSERT (! info->shared || srel != NULL);
3843 gotent = gotent->next;
3846 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3847 BFD_ASSERT(sgot != NULL);
3848 BFD_ASSERT(gotent->addend == 0);
3850 bfd_put_64 (output_bfd, plt_addr,
3851 sgot->contents + gotent->got_offset);
3855 outrel.r_offset = (sgot->output_section->vma
3856 + sgot->output_offset
3857 + gotent->got_offset);
3858 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3859 outrel.r_addend = plt_addr;
3861 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3862 ((Elf64_External_Rela *)
3864 + srel->reloc_count++);
3865 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3866 <= srel->_cooked_size);
3869 gotent = gotent->next;
3871 while (gotent != NULL);
3874 else if (alpha_elf_dynamic_symbol_p (h, info))
3876 /* Fill in the dynamic relocations for this symbol's .got entries. */
3878 Elf_Internal_Rela outrel;
3879 struct alpha_elf_got_entry *gotent;
3881 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3882 BFD_ASSERT (srel != NULL);
3884 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3885 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3887 gotent = gotent->next)
3889 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3890 outrel.r_offset = (sgot->output_section->vma
3891 + sgot->output_offset
3892 + gotent->got_offset);
3893 outrel.r_addend = gotent->addend;
3895 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3896 ((Elf64_External_Rela *)srel->contents
3897 + srel->reloc_count++));
3898 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3899 <= srel->_cooked_size);
3903 /* Mark some specially defined symbols as absolute. */
3904 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3905 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3906 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3907 sym->st_shndx = SHN_ABS;
3912 /* Finish up the dynamic sections. */
3915 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3917 struct bfd_link_info *info;
3922 dynobj = elf_hash_table (info)->dynobj;
3923 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3925 if (elf_hash_table (info)->dynamic_sections_created)
3928 Elf64_External_Dyn *dyncon, *dynconend;
3930 splt = bfd_get_section_by_name (dynobj, ".plt");
3931 BFD_ASSERT (splt != NULL && sdyn != NULL);
3933 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3934 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3935 for (; dyncon < dynconend; dyncon++)
3937 Elf_Internal_Dyn dyn;
3941 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3956 /* My interpretation of the TIS v1.1 ELF document indicates
3957 that RELASZ should not include JMPREL. This is not what
3958 the rest of the BFD does. It is, however, what the
3959 glibc ld.so wants. Do this fixup here until we found
3960 out who is right. */
3961 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3965 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3970 s = bfd_get_section_by_name (output_bfd, name);
3971 dyn.d_un.d_ptr = (s ? s->vma : 0);
3975 s = bfd_get_section_by_name (output_bfd, name);
3977 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3981 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3984 /* Initialize the PLT0 entry */
3985 if (splt->_raw_size > 0)
3987 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3988 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3989 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3990 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3992 /* The next two words will be filled in by ld.so */
3993 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3994 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
3996 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
4004 /* We need to use a special link routine to handle the .mdebug section.
4005 We need to merge all instances of these sections together, not write
4006 them all out sequentially. */
4009 elf64_alpha_final_link (abfd, info)
4011 struct bfd_link_info *info;
4014 struct bfd_link_order *p;
4015 asection *mdebug_sec;
4016 struct ecoff_debug_info debug;
4017 const struct ecoff_debug_swap *swap
4018 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4019 HDRR *symhdr = &debug.symbolic_header;
4020 PTR mdebug_handle = NULL;
4022 /* Go through the sections and collect the mdebug information. */
4024 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4026 if (strcmp (o->name, ".mdebug") == 0)
4028 struct extsym_info einfo;
4030 /* We have found the .mdebug section in the output file.
4031 Look through all the link_orders comprising it and merge
4032 the information together. */
4033 symhdr->magic = swap->sym_magic;
4034 /* FIXME: What should the version stamp be? */
4036 symhdr->ilineMax = 0;
4040 symhdr->isymMax = 0;
4041 symhdr->ioptMax = 0;
4042 symhdr->iauxMax = 0;
4044 symhdr->issExtMax = 0;
4047 symhdr->iextMax = 0;
4049 /* We accumulate the debugging information itself in the
4050 debug_info structure. */
4052 debug.external_dnr = NULL;
4053 debug.external_pdr = NULL;
4054 debug.external_sym = NULL;
4055 debug.external_opt = NULL;
4056 debug.external_aux = NULL;
4058 debug.ssext = debug.ssext_end = NULL;
4059 debug.external_fdr = NULL;
4060 debug.external_rfd = NULL;
4061 debug.external_ext = debug.external_ext_end = NULL;
4063 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4064 if (mdebug_handle == (PTR) NULL)
4073 static const char * const name[] =
4075 ".text", ".init", ".fini", ".data",
4076 ".rodata", ".sdata", ".sbss", ".bss"
4078 static const int sc[] = { scText, scInit, scFini, scData,
4079 scRData, scSData, scSBss, scBss };
4082 esym.cobol_main = 0;
4086 esym.asym.iss = issNil;
4087 esym.asym.st = stLocal;
4088 esym.asym.reserved = 0;
4089 esym.asym.index = indexNil;
4090 for (i = 0; i < 8; i++)
4092 esym.asym.sc = sc[i];
4093 s = bfd_get_section_by_name (abfd, name[i]);
4096 esym.asym.value = s->vma;
4097 last = s->vma + s->_raw_size;
4100 esym.asym.value = last;
4102 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4108 for (p = o->link_order_head;
4109 p != (struct bfd_link_order *) NULL;
4112 asection *input_section;
4114 const struct ecoff_debug_swap *input_swap;
4115 struct ecoff_debug_info input_debug;
4119 if (p->type != bfd_indirect_link_order)
4121 if (p->type == bfd_data_link_order)
4126 input_section = p->u.indirect.section;
4127 input_bfd = input_section->owner;
4129 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4130 || (get_elf_backend_data (input_bfd)
4131 ->elf_backend_ecoff_debug_swap) == NULL)
4133 /* I don't know what a non ALPHA ELF bfd would be
4134 doing with a .mdebug section, but I don't really
4135 want to deal with it. */
4139 input_swap = (get_elf_backend_data (input_bfd)
4140 ->elf_backend_ecoff_debug_swap);
4142 BFD_ASSERT (p->size == input_section->_raw_size);
4144 /* The ECOFF linking code expects that we have already
4145 read in the debugging information and set up an
4146 ecoff_debug_info structure, so we do that now. */
4147 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4151 if (! (bfd_ecoff_debug_accumulate
4152 (mdebug_handle, abfd, &debug, swap, input_bfd,
4153 &input_debug, input_swap, info)))
4156 /* Loop through the external symbols. For each one with
4157 interesting information, try to find the symbol in
4158 the linker global hash table and save the information
4159 for the output external symbols. */
4160 eraw_src = input_debug.external_ext;
4161 eraw_end = (eraw_src
4162 + (input_debug.symbolic_header.iextMax
4163 * input_swap->external_ext_size));
4165 eraw_src < eraw_end;
4166 eraw_src += input_swap->external_ext_size)
4170 struct alpha_elf_link_hash_entry *h;
4172 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4173 if (ext.asym.sc == scNil
4174 || ext.asym.sc == scUndefined
4175 || ext.asym.sc == scSUndefined)
4178 name = input_debug.ssext + ext.asym.iss;
4179 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4180 name, false, false, true);
4181 if (h == NULL || h->esym.ifd != -2)
4187 < input_debug.symbolic_header.ifdMax);
4188 ext.ifd = input_debug.ifdmap[ext.ifd];
4194 /* Free up the information we just read. */
4195 free (input_debug.line);
4196 free (input_debug.external_dnr);
4197 free (input_debug.external_pdr);
4198 free (input_debug.external_sym);
4199 free (input_debug.external_opt);
4200 free (input_debug.external_aux);
4201 free (input_debug.ss);
4202 free (input_debug.ssext);
4203 free (input_debug.external_fdr);
4204 free (input_debug.external_rfd);
4205 free (input_debug.external_ext);
4207 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4208 elf_link_input_bfd ignores this section. */
4209 input_section->flags &=~ SEC_HAS_CONTENTS;
4212 /* Build the external symbol information. */
4215 einfo.debug = &debug;
4217 einfo.failed = false;
4218 elf_link_hash_traverse (elf_hash_table (info),
4219 elf64_alpha_output_extsym,
4224 /* Set the size of the .mdebug section. */
4225 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4227 /* Skip this section later on (I don't think this currently
4228 matters, but someday it might). */
4229 o->link_order_head = (struct bfd_link_order *) NULL;
4235 /* Invoke the regular ELF backend linker to do all the work. */
4236 if (! bfd_elf64_bfd_final_link (abfd, info))
4239 /* Now write out the computed sections. */
4241 /* The .got subsections... */
4243 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4244 for (i = alpha_elf_hash_table(info)->got_list;
4246 i = alpha_elf_tdata(i)->got_link_next)
4250 /* elf_bfd_final_link already did everything in dynobj. */
4254 sgot = alpha_elf_tdata(i)->got;
4255 if (! bfd_set_section_contents (abfd, sgot->output_section,
4257 (file_ptr) sgot->output_offset,
4263 if (mdebug_sec != (asection *) NULL)
4265 BFD_ASSERT (abfd->output_has_begun);
4266 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4268 mdebug_sec->filepos))
4271 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4277 static enum elf_reloc_type_class
4278 elf64_alpha_reloc_type_class (rela)
4279 const Elf_Internal_Rela *rela;
4281 switch ((int) ELF64_R_TYPE (rela->r_info))
4283 case R_ALPHA_RELATIVE:
4284 return reloc_class_relative;
4285 case R_ALPHA_JMP_SLOT:
4286 return reloc_class_plt;
4288 return reloc_class_copy;
4290 return reloc_class_normal;
4294 /* ECOFF swapping routines. These are used when dealing with the
4295 .mdebug section, which is in the ECOFF debugging format. Copied
4296 from elf32-mips.c. */
4297 static const struct ecoff_debug_swap
4298 elf64_alpha_ecoff_debug_swap =
4300 /* Symbol table magic number. */
4302 /* Alignment of debugging information. E.g., 4. */
4304 /* Sizes of external symbolic information. */
4305 sizeof (struct hdr_ext),
4306 sizeof (struct dnr_ext),
4307 sizeof (struct pdr_ext),
4308 sizeof (struct sym_ext),
4309 sizeof (struct opt_ext),
4310 sizeof (struct fdr_ext),
4311 sizeof (struct rfd_ext),
4312 sizeof (struct ext_ext),
4313 /* Functions to swap in external symbolic data. */
4322 _bfd_ecoff_swap_tir_in,
4323 _bfd_ecoff_swap_rndx_in,
4324 /* Functions to swap out external symbolic data. */
4333 _bfd_ecoff_swap_tir_out,
4334 _bfd_ecoff_swap_rndx_out,
4335 /* Function to read in symbolic data. */
4336 elf64_alpha_read_ecoff_info
4339 /* Use a non-standard hash bucket size of 8. */
4341 const struct elf_size_info alpha_elf_size_info =
4343 sizeof (Elf64_External_Ehdr),
4344 sizeof (Elf64_External_Phdr),
4345 sizeof (Elf64_External_Shdr),
4346 sizeof (Elf64_External_Rel),
4347 sizeof (Elf64_External_Rela),
4348 sizeof (Elf64_External_Sym),
4349 sizeof (Elf64_External_Dyn),
4350 sizeof (Elf_External_Note),
4354 ELFCLASS64, EV_CURRENT,
4355 bfd_elf64_write_out_phdrs,
4356 bfd_elf64_write_shdrs_and_ehdr,
4357 bfd_elf64_write_relocs,
4358 bfd_elf64_swap_symbol_out,
4359 bfd_elf64_slurp_reloc_table,
4360 bfd_elf64_slurp_symbol_table,
4361 bfd_elf64_swap_dyn_in,
4362 bfd_elf64_swap_dyn_out,
4369 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4370 #define TARGET_LITTLE_NAME "elf64-alpha"
4371 #define ELF_ARCH bfd_arch_alpha
4372 #define ELF_MACHINE_CODE EM_ALPHA
4373 #define ELF_MAXPAGESIZE 0x10000
4375 #define bfd_elf64_bfd_link_hash_table_create \
4376 elf64_alpha_bfd_link_hash_table_create
4378 #define bfd_elf64_bfd_reloc_type_lookup \
4379 elf64_alpha_bfd_reloc_type_lookup
4380 #define elf_info_to_howto \
4381 elf64_alpha_info_to_howto
4383 #define bfd_elf64_mkobject \
4384 elf64_alpha_mkobject
4385 #define elf_backend_object_p \
4386 elf64_alpha_object_p
4388 #define elf_backend_section_from_shdr \
4389 elf64_alpha_section_from_shdr
4390 #define elf_backend_section_flags \
4391 elf64_alpha_section_flags
4392 #define elf_backend_fake_sections \
4393 elf64_alpha_fake_sections
4395 #define bfd_elf64_bfd_is_local_label_name \
4396 elf64_alpha_is_local_label_name
4397 #define bfd_elf64_find_nearest_line \
4398 elf64_alpha_find_nearest_line
4399 #define bfd_elf64_bfd_relax_section \
4400 elf64_alpha_relax_section
4402 #define elf_backend_add_symbol_hook \
4403 elf64_alpha_add_symbol_hook
4404 #define elf_backend_check_relocs \
4405 elf64_alpha_check_relocs
4406 #define elf_backend_create_dynamic_sections \
4407 elf64_alpha_create_dynamic_sections
4408 #define elf_backend_adjust_dynamic_symbol \
4409 elf64_alpha_adjust_dynamic_symbol
4410 #define elf_backend_always_size_sections \
4411 elf64_alpha_always_size_sections
4412 #define elf_backend_size_dynamic_sections \
4413 elf64_alpha_size_dynamic_sections
4414 #define elf_backend_relocate_section \
4415 elf64_alpha_relocate_section
4416 #define elf_backend_finish_dynamic_symbol \
4417 elf64_alpha_finish_dynamic_symbol
4418 #define elf_backend_finish_dynamic_sections \
4419 elf64_alpha_finish_dynamic_sections
4420 #define bfd_elf64_bfd_final_link \
4421 elf64_alpha_final_link
4422 #define elf_backend_reloc_type_class \
4423 elf64_alpha_reloc_type_class
4425 #define elf_backend_ecoff_debug_swap \
4426 &elf64_alpha_ecoff_debug_swap
4428 #define elf_backend_size_info \
4431 /* A few constants that determine how the .plt section is set up. */
4432 #define elf_backend_want_got_plt 0
4433 #define elf_backend_plt_readonly 0
4434 #define elf_backend_want_plt_sym 1
4435 #define elf_backend_got_header_size 0
4436 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4438 #include "elf64-target.h"