1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
52 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
54 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
66 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd *, bfd_reloc_code_real_type));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
77 static boolean elf64_alpha_fake_sections
78 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
79 static boolean elf64_alpha_create_got_section
80 PARAMS((bfd *, struct bfd_link_info *));
81 static boolean elf64_alpha_create_dynamic_sections
82 PARAMS((bfd *, struct bfd_link_info *));
84 static boolean elf64_alpha_read_ecoff_info
85 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
86 static boolean elf64_alpha_is_local_label_name
87 PARAMS((bfd *, const char *));
88 static boolean elf64_alpha_find_nearest_line
89 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
90 const char **, unsigned int *));
92 #if defined(__STDC__) || defined(ALMOST_STDC)
93 struct alpha_elf_link_hash_entry;
96 static boolean elf64_alpha_output_extsym
97 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
99 static boolean elf64_alpha_can_merge_gots
100 PARAMS((bfd *, bfd *));
101 static void elf64_alpha_merge_gots
102 PARAMS((bfd *, bfd *));
103 static boolean elf64_alpha_calc_got_offsets_for_symbol
104 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
105 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
106 static boolean elf64_alpha_size_got_sections
107 PARAMS ((bfd *, struct bfd_link_info *));
108 static boolean elf64_alpha_always_size_sections
109 PARAMS ((bfd *, struct bfd_link_info *));
110 static boolean elf64_alpha_calc_dynrel_sizes
111 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
112 static boolean elf64_alpha_add_symbol_hook
113 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
114 const char **, flagword *, asection **, bfd_vma *));
115 static boolean elf64_alpha_check_relocs
116 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
117 const Elf_Internal_Rela *));
118 static boolean elf64_alpha_adjust_dynamic_symbol
119 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
120 static boolean elf64_alpha_size_dynamic_sections
121 PARAMS((bfd *, struct bfd_link_info *));
122 static boolean elf64_alpha_relocate_section
123 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
124 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
125 static boolean elf64_alpha_finish_dynamic_symbol
126 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
127 Elf_Internal_Sym *));
128 static boolean elf64_alpha_finish_dynamic_sections
129 PARAMS((bfd *, struct bfd_link_info *));
130 static boolean elf64_alpha_final_link
131 PARAMS((bfd *, struct bfd_link_info *));
132 static boolean elf64_alpha_merge_ind_symbols
133 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
134 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
135 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
136 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
139 struct alpha_elf_link_hash_entry
141 struct elf_link_hash_entry root;
143 /* External symbol information. */
146 /* Cumulative flags for all the .got entries. */
149 /* Contexts (LITUSE) in which a literal was referenced. */
150 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
151 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
152 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
153 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
155 /* Used to implement multiple .got subsections. */
156 struct alpha_elf_got_entry
158 struct alpha_elf_got_entry *next;
160 /* which .got subsection? */
163 /* the addend in effect for this entry. */
164 bfd_signed_vma addend;
166 /* the .got offset for this entry. */
171 /* An additional flag. */
172 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
177 /* used to count non-got, non-plt relocations for delayed sizing
178 of relocation sections. */
179 struct alpha_elf_reloc_entry
181 struct alpha_elf_reloc_entry *next;
183 /* which .reloc section? */
186 /* what kind of relocation? */
189 /* is this against read-only section? */
190 unsigned int reltext : 1;
192 /* how many did we find? */
197 /* Alpha ELF linker hash table. */
199 struct alpha_elf_link_hash_table
201 struct elf_link_hash_table root;
203 /* The head of a list of .got subsections linked through
204 alpha_elf_tdata(abfd)->got_link_next. */
208 /* Look up an entry in a Alpha ELF linker hash table. */
210 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
211 ((struct alpha_elf_link_hash_entry *) \
212 elf_link_hash_lookup (&(table)->root, (string), (create), \
215 /* Traverse a Alpha ELF linker hash table. */
217 #define alpha_elf_link_hash_traverse(table, func, info) \
218 (elf_link_hash_traverse \
220 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
223 /* Get the Alpha ELF linker hash table from a link_info structure. */
225 #define alpha_elf_hash_table(p) \
226 ((struct alpha_elf_link_hash_table *) ((p)->hash))
228 /* Get the object's symbols as our own entry type. */
230 #define alpha_elf_sym_hashes(abfd) \
231 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
233 /* Should we do dynamic things to this symbol? */
236 alpha_elf_dynamic_symbol_p (h, info)
237 struct elf_link_hash_entry *h;
238 struct bfd_link_info *info;
243 while (h->root.type == bfd_link_hash_indirect
244 || h->root.type == bfd_link_hash_warning)
245 h = (struct elf_link_hash_entry *) h->root.u.i.link;
247 if (h->dynindx == -1)
250 if (h->root.type == bfd_link_hash_undefweak
251 || h->root.type == bfd_link_hash_defweak)
254 switch (ELF_ST_VISIBILITY (h->other))
262 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
267 if ((info->shared && !info->symbolic)
268 || ((h->elf_link_hash_flags
269 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
270 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
276 /* Create an entry in a Alpha ELF linker hash table. */
278 static struct bfd_hash_entry *
279 elf64_alpha_link_hash_newfunc (entry, table, string)
280 struct bfd_hash_entry *entry;
281 struct bfd_hash_table *table;
284 struct alpha_elf_link_hash_entry *ret =
285 (struct alpha_elf_link_hash_entry *) entry;
287 /* Allocate the structure if it has not already been allocated by a
289 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
290 ret = ((struct alpha_elf_link_hash_entry *)
291 bfd_hash_allocate (table,
292 sizeof (struct alpha_elf_link_hash_entry)));
293 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
294 return (struct bfd_hash_entry *) ret;
296 /* Call the allocation method of the superclass. */
297 ret = ((struct alpha_elf_link_hash_entry *)
298 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
300 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
302 /* Set local fields. */
303 memset (&ret->esym, 0, sizeof (EXTR));
304 /* We use -2 as a marker to indicate that the information has
305 not been set. -1 means there is no associated ifd. */
308 ret->got_entries = NULL;
309 ret->reloc_entries = NULL;
312 return (struct bfd_hash_entry *) ret;
315 /* Create a Alpha ELF linker hash table. */
317 static struct bfd_link_hash_table *
318 elf64_alpha_bfd_link_hash_table_create (abfd)
321 struct alpha_elf_link_hash_table *ret;
323 ret = ((struct alpha_elf_link_hash_table *)
324 bfd_zalloc (abfd, sizeof (struct alpha_elf_link_hash_table)));
325 if (ret == (struct alpha_elf_link_hash_table *) NULL)
328 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
329 elf64_alpha_link_hash_newfunc))
331 bfd_release (abfd, ret);
335 return &ret->root.root;
338 /* We have some private fields hanging off of the elf_tdata structure. */
340 struct alpha_elf_obj_tdata
342 struct elf_obj_tdata root;
344 /* For every input file, these are the got entries for that object's
346 struct alpha_elf_got_entry ** local_got_entries;
348 /* For every input file, this is the object that owns the got that
349 this input file uses. */
352 /* For every got, this is a linked list through the objects using this got */
353 bfd *in_got_link_next;
355 /* For every got, this is a link to the next got subsegment. */
358 /* For every got, this is the section. */
361 /* For every got, this is it's total number of *entries*. */
362 int total_got_entries;
364 /* For every got, this is the sum of the number of *entries* required
365 to hold all of the member object's local got. */
366 int n_local_got_entries;
369 #define alpha_elf_tdata(abfd) \
370 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
373 elf64_alpha_mkobject (abfd)
376 abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
377 if (abfd->tdata.any == NULL)
383 elf64_alpha_object_p (abfd)
386 /* Allocate our special target data. */
387 struct alpha_elf_obj_tdata *new_tdata;
388 new_tdata = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
389 if (new_tdata == NULL)
391 new_tdata->root = *abfd->tdata.elf_obj_data;
392 abfd->tdata.any = new_tdata;
394 /* Set the right machine number for an Alpha ELF file. */
395 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
398 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
399 from smaller values. Start with zero, widen, *then* decrement. */
400 #define MINUS_ONE (((bfd_vma)0) - 1)
402 #define SKIP_HOWTO(N) \
403 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
405 static reloc_howto_type elf64_alpha_howto_table[] =
407 HOWTO (R_ALPHA_NONE, /* type */
409 0, /* size (0 = byte, 1 = short, 2 = long) */
411 true, /* pc_relative */
413 complain_overflow_dont, /* complain_on_overflow */
414 elf64_alpha_reloc_nil, /* special_function */
416 false, /* partial_inplace */
419 true), /* pcrel_offset */
421 /* A 32 bit reference to a symbol. */
422 HOWTO (R_ALPHA_REFLONG, /* type */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
426 false, /* pc_relative */
428 complain_overflow_bitfield, /* complain_on_overflow */
429 0, /* special_function */
430 "REFLONG", /* name */
431 false, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 false), /* pcrel_offset */
436 /* A 64 bit reference to a symbol. */
437 HOWTO (R_ALPHA_REFQUAD, /* type */
439 4, /* size (0 = byte, 1 = short, 2 = long) */
441 false, /* pc_relative */
443 complain_overflow_bitfield, /* complain_on_overflow */
444 0, /* special_function */
445 "REFQUAD", /* name */
446 false, /* partial_inplace */
447 MINUS_ONE, /* src_mask */
448 MINUS_ONE, /* dst_mask */
449 false), /* pcrel_offset */
451 /* A 32 bit GP relative offset. This is just like REFLONG except
452 that when the value is used the value of the gp register will be
454 HOWTO (R_ALPHA_GPREL32, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 false, /* pc_relative */
460 complain_overflow_bitfield, /* complain_on_overflow */
461 0, /* special_function */
462 "GPREL32", /* name */
463 false, /* partial_inplace */
464 0xffffffff, /* src_mask */
465 0xffffffff, /* dst_mask */
466 false), /* pcrel_offset */
468 /* Used for an instruction that refers to memory off the GP register. */
469 HOWTO (R_ALPHA_LITERAL, /* type */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
473 false, /* pc_relative */
475 complain_overflow_signed, /* complain_on_overflow */
476 0, /* special_function */
477 "ELF_LITERAL", /* name */
478 false, /* partial_inplace */
479 0xffff, /* src_mask */
480 0xffff, /* dst_mask */
481 false), /* pcrel_offset */
483 /* This reloc only appears immediately following an ELF_LITERAL reloc.
484 It identifies a use of the literal. The symbol index is special:
485 1 means the literal address is in the base register of a memory
486 format instruction; 2 means the literal address is in the byte
487 offset register of a byte-manipulation instruction; 3 means the
488 literal address is in the target register of a jsr instruction.
489 This does not actually do any relocation. */
490 HOWTO (R_ALPHA_LITUSE, /* type */
492 1, /* size (0 = byte, 1 = short, 2 = long) */
494 false, /* pc_relative */
496 complain_overflow_dont, /* complain_on_overflow */
497 elf64_alpha_reloc_nil, /* special_function */
499 false, /* partial_inplace */
502 false), /* pcrel_offset */
504 /* Load the gp register. This is always used for a ldah instruction
505 which loads the upper 16 bits of the gp register. The symbol
506 index of the GPDISP instruction is an offset in bytes to the lda
507 instruction that loads the lower 16 bits. The value to use for
508 the relocation is the difference between the GP value and the
509 current location; the load will always be done against a register
510 holding the current address.
512 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
513 any offset is present in the instructions, it is an offset from
514 the register to the ldah instruction. This lets us avoid any
515 stupid hackery like inventing a gp value to do partial relocation
516 against. Also unlike ECOFF, we do the whole relocation off of
517 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
518 space consuming bit, that, since all the information was present
519 in the GPDISP_HI16 reloc. */
520 HOWTO (R_ALPHA_GPDISP, /* type */
522 2, /* size (0 = byte, 1 = short, 2 = long) */
524 false, /* pc_relative */
526 complain_overflow_dont, /* complain_on_overflow */
527 elf64_alpha_reloc_gpdisp, /* special_function */
529 false, /* partial_inplace */
530 0xffff, /* src_mask */
531 0xffff, /* dst_mask */
532 true), /* pcrel_offset */
534 /* A 21 bit branch. */
535 HOWTO (R_ALPHA_BRADDR, /* type */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
539 true, /* pc_relative */
541 complain_overflow_signed, /* complain_on_overflow */
542 0, /* special_function */
544 false, /* partial_inplace */
545 0x1fffff, /* src_mask */
546 0x1fffff, /* dst_mask */
547 true), /* pcrel_offset */
549 /* A hint for a jump to a register. */
550 HOWTO (R_ALPHA_HINT, /* type */
552 1, /* size (0 = byte, 1 = short, 2 = long) */
554 true, /* pc_relative */
556 complain_overflow_dont, /* complain_on_overflow */
557 0, /* special_function */
559 false, /* partial_inplace */
560 0x3fff, /* src_mask */
561 0x3fff, /* dst_mask */
562 true), /* pcrel_offset */
564 /* 16 bit PC relative offset. */
565 HOWTO (R_ALPHA_SREL16, /* type */
567 1, /* size (0 = byte, 1 = short, 2 = long) */
569 true, /* pc_relative */
571 complain_overflow_signed, /* complain_on_overflow */
572 0, /* special_function */
574 false, /* partial_inplace */
575 0xffff, /* src_mask */
576 0xffff, /* dst_mask */
577 true), /* pcrel_offset */
579 /* 32 bit PC relative offset. */
580 HOWTO (R_ALPHA_SREL32, /* type */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
584 true, /* pc_relative */
586 complain_overflow_signed, /* complain_on_overflow */
587 0, /* special_function */
589 false, /* partial_inplace */
590 0xffffffff, /* src_mask */
591 0xffffffff, /* dst_mask */
592 true), /* pcrel_offset */
594 /* A 64 bit PC relative offset. */
595 HOWTO (R_ALPHA_SREL64, /* type */
597 4, /* size (0 = byte, 1 = short, 2 = long) */
599 true, /* pc_relative */
601 complain_overflow_signed, /* complain_on_overflow */
602 0, /* special_function */
604 false, /* partial_inplace */
605 MINUS_ONE, /* src_mask */
606 MINUS_ONE, /* dst_mask */
607 true), /* pcrel_offset */
609 /* Skip 12 - 16; deprecated ECOFF relocs. */
616 /* The high 16 bits of the displacement from GP to the target. */
617 HOWTO (R_ALPHA_GPRELHIGH,
619 1, /* size (0 = byte, 1 = short, 2 = long) */
621 false, /* pc_relative */
623 complain_overflow_signed, /* complain_on_overflow */
624 0, /* special_function */
625 "GPRELHIGH", /* name */
626 false, /* partial_inplace */
627 0xffff, /* src_mask */
628 0xffff, /* dst_mask */
629 false), /* pcrel_offset */
631 /* The low 16 bits of the displacement from GP to the target. */
632 HOWTO (R_ALPHA_GPRELLOW,
634 1, /* size (0 = byte, 1 = short, 2 = long) */
636 false, /* pc_relative */
638 complain_overflow_dont, /* complain_on_overflow */
639 0, /* special_function */
640 "GPRELLOW", /* name */
641 false, /* partial_inplace */
642 0xffff, /* src_mask */
643 0xffff, /* dst_mask */
644 false), /* pcrel_offset */
646 /* A 16-bit displacement from the GP to the target. */
647 HOWTO (R_ALPHA_GPREL16,
649 1, /* size (0 = byte, 1 = short, 2 = long) */
651 false, /* pc_relative */
653 complain_overflow_signed, /* complain_on_overflow */
654 0, /* special_function */
655 "GPREL16", /* name */
656 false, /* partial_inplace */
657 0xffff, /* src_mask */
658 0xffff, /* dst_mask */
659 false), /* pcrel_offset */
661 /* Skip 20 - 23; deprecated ECOFF relocs. */
667 /* Misc ELF relocations. */
669 /* A dynamic relocation to copy the target into our .dynbss section. */
670 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
671 is present because every other ELF has one, but should not be used
672 because .dynbss is an ugly thing. */
679 complain_overflow_dont,
680 bfd_elf_generic_reloc,
687 /* A dynamic relocation for a .got entry. */
688 HOWTO (R_ALPHA_GLOB_DAT,
694 complain_overflow_dont,
695 bfd_elf_generic_reloc,
702 /* A dynamic relocation for a .plt entry. */
703 HOWTO (R_ALPHA_JMP_SLOT,
709 complain_overflow_dont,
710 bfd_elf_generic_reloc,
717 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
718 HOWTO (R_ALPHA_RELATIVE,
724 complain_overflow_dont,
725 bfd_elf_generic_reloc,
733 /* A relocation function which doesn't do anything. */
735 static bfd_reloc_status_type
736 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
737 bfd *abfd ATTRIBUTE_UNUSED;
739 asymbol *sym ATTRIBUTE_UNUSED;
740 PTR data ATTRIBUTE_UNUSED;
743 char **error_message ATTRIBUTE_UNUSED;
746 reloc->address += sec->output_offset;
750 /* A relocation function used for an unsupported reloc. */
752 static bfd_reloc_status_type
753 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
754 bfd *abfd ATTRIBUTE_UNUSED;
756 asymbol *sym ATTRIBUTE_UNUSED;
757 PTR data ATTRIBUTE_UNUSED;
760 char **error_message ATTRIBUTE_UNUSED;
763 reloc->address += sec->output_offset;
764 return bfd_reloc_notsupported;
767 /* Do the work of the GPDISP relocation. */
769 static bfd_reloc_status_type
770 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
776 bfd_reloc_status_type ret = bfd_reloc_ok;
778 unsigned long i_ldah, i_lda;
780 i_ldah = bfd_get_32 (abfd, p_ldah);
781 i_lda = bfd_get_32 (abfd, p_lda);
783 /* Complain if the instructions are not correct. */
784 if (((i_ldah >> 26) & 0x3f) != 0x09
785 || ((i_lda >> 26) & 0x3f) != 0x08)
786 ret = bfd_reloc_dangerous;
788 /* Extract the user-supplied offset, mirroring the sign extensions
789 that the instructions perform. */
790 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
791 addend = (addend ^ 0x80008000) - 0x80008000;
795 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
796 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
797 ret = bfd_reloc_overflow;
799 /* compensate for the sign extension again. */
800 i_ldah = ((i_ldah & 0xffff0000)
801 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
802 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
804 bfd_put_32 (abfd, i_ldah, p_ldah);
805 bfd_put_32 (abfd, i_lda, p_lda);
810 /* The special function for the GPDISP reloc. */
812 static bfd_reloc_status_type
813 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
816 arelent *reloc_entry;
817 asymbol *sym ATTRIBUTE_UNUSED;
819 asection *input_section;
823 bfd_reloc_status_type ret;
824 bfd_vma gp, relocation;
825 bfd_byte *p_ldah, *p_lda;
827 /* Don't do anything if we're not doing a final link. */
830 reloc_entry->address += input_section->output_offset;
834 if (reloc_entry->address > input_section->_cooked_size ||
835 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
836 return bfd_reloc_outofrange;
838 /* The gp used in the portion of the output object to which this
839 input object belongs is cached on the input bfd. */
840 gp = _bfd_get_gp_value (abfd);
842 relocation = (input_section->output_section->vma
843 + input_section->output_offset
844 + reloc_entry->address);
846 p_ldah = (bfd_byte *) data + reloc_entry->address;
847 p_lda = p_ldah + reloc_entry->addend;
849 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
851 /* Complain if the instructions are not correct. */
852 if (ret == bfd_reloc_dangerous)
853 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
858 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
862 bfd_reloc_code_real_type bfd_reloc_val;
866 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
868 {BFD_RELOC_NONE, R_ALPHA_NONE},
869 {BFD_RELOC_32, R_ALPHA_REFLONG},
870 {BFD_RELOC_64, R_ALPHA_REFQUAD},
871 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
872 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
873 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
874 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
875 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
876 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
877 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
878 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
879 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
880 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
881 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
882 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
883 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
886 /* Given a BFD reloc type, return a HOWTO structure. */
888 static reloc_howto_type *
889 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
890 bfd *abfd ATTRIBUTE_UNUSED;
891 bfd_reloc_code_real_type code;
893 const struct elf_reloc_map *i, *e;
894 i = e = elf64_alpha_reloc_map;
895 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
898 if (i->bfd_reloc_val == code)
899 return &elf64_alpha_howto_table[i->elf_reloc_val];
904 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
907 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
908 bfd *abfd ATTRIBUTE_UNUSED;
910 Elf64_Internal_Rela *dst;
914 r_type = ELF64_R_TYPE(dst->r_info);
915 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
916 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
919 /* These functions do relaxation for Alpha ELF.
921 Currently I'm only handling what I can do with existing compiler
922 and assembler support, which means no instructions are removed,
923 though some may be nopped. At this time GCC does not emit enough
924 information to do all of the relaxing that is possible. It will
925 take some not small amount of work for that to happen.
927 There are a couple of interesting papers that I once read on this
928 subject, that I cannot find references to at the moment, that
929 related to Alpha in particular. They are by David Wall, then of
934 #define INSN_JSR 0x68004000
935 #define INSN_JSR_MASK 0xfc00c000
939 #define INSN_UNOP 0x2fe00000
941 struct alpha_relax_info
946 Elf_Internal_Rela *relocs, *relend;
947 struct bfd_link_info *link_info;
948 boolean changed_contents;
949 boolean changed_relocs;
953 struct alpha_elf_link_hash_entry *h;
954 struct alpha_elf_got_entry *gotent;
958 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
959 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
960 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
962 static boolean elf64_alpha_relax_without_lituse
963 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
964 Elf_Internal_Rela *irel));
966 static bfd_vma elf64_alpha_relax_opt_call
967 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
969 static boolean elf64_alpha_relax_section
970 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
973 static Elf_Internal_Rela *
974 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
975 Elf_Internal_Rela *rel, *relend;
981 if (rel->r_offset == offset
982 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
989 static Elf_Internal_Rela *
990 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
991 struct alpha_relax_info *info;
993 Elf_Internal_Rela *irel, *irelend;
995 Elf_Internal_Rela *urel;
1000 boolean lit_reused = false;
1001 boolean all_optimized = true;
1002 unsigned int lit_insn;
1004 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1005 if (lit_insn >> 26 != OP_LDQ)
1007 ((*_bfd_error_handler)
1008 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1009 bfd_get_filename (info->abfd), info->sec->name,
1010 (unsigned long)irel->r_offset));
1014 /* Summarize how this particular LITERAL is used. */
1015 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1017 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1019 if (urel->r_addend >= 0 && urel->r_addend <= 3)
1020 flags |= 1 << urel->r_addend;
1023 /* A little preparation for the loop... */
1024 disp = symval - info->gp;
1026 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1030 bfd_signed_vma xdisp;
1032 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1034 switch (urel->r_addend)
1036 default: /* 0 = ADDRESS FORMAT */
1037 /* This type is really just a placeholder to note that all
1038 uses cannot be optimized, but to still allow some. */
1039 all_optimized = false;
1042 case 1: /* MEM FORMAT */
1043 /* We can always optimize 16-bit displacements. */
1045 /* Extract the displacement from the instruction, sign-extending
1046 it if necessary, then test whether it is within 16 or 32 bits
1047 displacement from GP. */
1048 insn_disp = insn & 0x0000ffff;
1049 if (insn_disp & 0x00008000)
1050 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1052 xdisp = disp + insn_disp;
1053 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1054 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1058 /* Take the op code and dest from this insn, take the base
1059 register from the literal insn. Leave the offset alone. */
1060 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1061 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1063 urel->r_addend = irel->r_addend;
1064 info->changed_relocs = true;
1066 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1067 info->changed_contents = true;
1070 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1071 else if (fits32 && !(flags & ~6))
1073 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1075 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1077 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1078 bfd_put_32 (info->abfd, lit_insn,
1079 info->contents + irel->r_offset);
1081 info->changed_contents = true;
1083 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1085 urel->r_addend = irel->r_addend;
1086 info->changed_relocs = true;
1089 all_optimized = false;
1092 case 2: /* BYTE OFFSET FORMAT */
1093 /* We can always optimize byte instructions. */
1095 /* FIXME: sanity check the insn for byte op. Check that the
1096 literal dest reg is indeed Rb in the byte insn. */
1098 insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
1100 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1102 info->changed_relocs = true;
1104 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1105 info->changed_contents = true;
1108 case 3: /* CALL FORMAT */
1110 /* If not zero, place to jump without needing pv. */
1111 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1112 bfd_vma org = (info->sec->output_section->vma
1113 + info->sec->output_offset
1114 + urel->r_offset + 4);
1115 bfd_signed_vma odisp;
1117 odisp = (optdest ? optdest : symval) - org;
1118 if (odisp >= -0x400000 && odisp < 0x400000)
1120 Elf_Internal_Rela *xrel;
1122 /* Preserve branch prediction call stack when possible. */
1123 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1124 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1126 insn = (OP_BR << 26) | (insn & 0x03e00000);
1128 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1130 urel->r_addend = irel->r_addend;
1133 urel->r_addend += optdest - symval;
1135 all_optimized = false;
1137 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1139 /* Kill any HINT reloc that might exist for this insn. */
1140 xrel = (elf64_alpha_find_reloc_at_ofs
1141 (info->relocs, info->relend, urel->r_offset,
1144 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1146 info->changed_contents = true;
1147 info->changed_relocs = true;
1150 all_optimized = false;
1152 /* Even if the target is not in range for a direct branch,
1153 if we share a GP, we can eliminate the gp reload. */
1156 Elf_Internal_Rela *gpdisp
1157 = (elf64_alpha_find_reloc_at_ofs
1158 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1161 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1162 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1163 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1164 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1166 /* Verify that the instruction is "ldah $29,0($26)".
1167 Consider a function that ends in a noreturn call,
1168 and that the next function begins with an ldgp,
1169 and that by accident there is no padding between.
1170 In that case the insn would use $27 as the base. */
1171 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1173 bfd_put_32 (info->abfd, INSN_UNOP, p_ldah);
1174 bfd_put_32 (info->abfd, INSN_UNOP, p_lda);
1176 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1177 info->changed_contents = true;
1178 info->changed_relocs = true;
1187 /* If all cases were optimized, we can reduce the use count on this
1188 got entry by one, possibly eliminating it. */
1191 info->gotent->use_count -= 1;
1192 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1194 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1196 /* If the literal instruction is no longer needed (it may have been
1197 reused. We can eliminate it.
1198 ??? For now, I don't want to deal with compacting the section,
1199 so just nop it out. */
1202 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1203 info->changed_relocs = true;
1205 bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
1206 info->changed_contents = true;
1210 return irel + count;
1214 elf64_alpha_relax_opt_call (info, symval)
1215 struct alpha_relax_info *info;
1218 /* If the function has the same gp, and we can identify that the
1219 function does not use its function pointer, we can eliminate the
1222 /* If the symbol is marked NOPV, we are being told the function never
1223 needs its procedure value. */
1224 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1227 /* If the symbol is marked STD_GP, we are being told the function does
1228 a normal ldgp in the first two words. */
1229 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1232 /* Otherwise, we may be able to identify a GP load in the first two
1233 words, which we can then skip. */
1236 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1239 /* Load the relocations from the section that the target symbol is in. */
1240 if (info->sec == info->tsec)
1242 tsec_relocs = info->relocs;
1243 tsec_relend = info->relend;
1248 tsec_relocs = (_bfd_elf64_link_read_relocs
1249 (info->abfd, info->tsec, (PTR) NULL,
1250 (Elf_Internal_Rela *) NULL,
1251 info->link_info->keep_memory));
1252 if (tsec_relocs == NULL)
1254 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1255 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1258 /* Recover the symbol's offset within the section. */
1259 ofs = (symval - info->tsec->output_section->vma
1260 - info->tsec->output_offset);
1262 /* Look for a GPDISP reloc. */
1263 gpdisp = (elf64_alpha_find_reloc_at_ofs
1264 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1266 if (!gpdisp || gpdisp->r_addend != 4)
1276 /* We've now determined that we can skip an initial gp load. Verify
1277 that the call and the target use the same gp. */
1278 if (info->link_info->hash->creator != info->tsec->owner->xvec
1279 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1286 elf64_alpha_relax_without_lituse (info, symval, irel)
1287 struct alpha_relax_info *info;
1289 Elf_Internal_Rela *irel;
1292 bfd_signed_vma disp;
1294 /* Get the instruction. */
1295 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1297 if (insn >> 26 != OP_LDQ)
1299 ((*_bfd_error_handler)
1300 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1301 bfd_get_filename (info->abfd), info->sec->name,
1302 (unsigned long) irel->r_offset));
1306 /* So we aren't told much. Do what we can with the address load and
1307 fake the rest. All of the optimizations here require that the
1308 offset from the GP fit in 16 bits. */
1310 disp = symval - info->gp;
1311 if (disp < -0x8000 || disp >= 0x8000)
1314 /* On the LITERAL instruction itself, consider exchanging
1315 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1317 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1318 bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
1319 info->changed_contents = true;
1321 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1322 info->changed_relocs = true;
1324 /* Reduce the use count on this got entry by one, possibly
1326 info->gotent->use_count -= 1;
1327 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1329 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1331 /* ??? Search forward through this basic block looking for insns
1332 that use the target register. Stop after an insn modifying the
1333 register is seen, or after a branch or call.
1335 Any such memory load insn may be substituted by a load directly
1336 off the GP. This allows the memory load insn to be issued before
1337 the calculated GP register would otherwise be ready.
1339 Any such jsr insn can be replaced by a bsr if it is in range.
1341 This would mean that we'd have to _add_ relocations, the pain of
1342 which gives one pause. */
1348 elf64_alpha_relax_section (abfd, sec, link_info, again)
1351 struct bfd_link_info *link_info;
1354 Elf_Internal_Shdr *symtab_hdr;
1355 Elf_Internal_Rela *internal_relocs;
1356 Elf_Internal_Rela *free_relocs = NULL;
1357 Elf_Internal_Rela *irel, *irelend;
1358 bfd_byte *free_contents = NULL;
1359 Elf64_External_Sym *extsyms = NULL;
1360 Elf64_External_Sym *free_extsyms = NULL;
1361 struct alpha_elf_got_entry **local_got_entries;
1362 struct alpha_relax_info info;
1364 /* We are not currently changing any sizes, so only one pass. */
1367 if (link_info->relocateable
1368 || (sec->flags & SEC_RELOC) == 0
1369 || sec->reloc_count == 0)
1372 /* If this is the first time we have been called for this section,
1373 initialize the cooked size. */
1374 if (sec->_cooked_size == 0)
1375 sec->_cooked_size = sec->_raw_size;
1377 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1378 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1380 /* Load the relocations for this section. */
1381 internal_relocs = (_bfd_elf64_link_read_relocs
1382 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1383 link_info->keep_memory));
1384 if (internal_relocs == NULL)
1386 if (! link_info->keep_memory)
1387 free_relocs = internal_relocs;
1389 memset(&info, 0, sizeof (info));
1392 info.link_info = link_info;
1393 info.relocs = internal_relocs;
1394 info.relend = irelend = internal_relocs + sec->reloc_count;
1396 /* Find the GP for this object. */
1397 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1400 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1401 info.gp = _bfd_get_gp_value (info.gotobj);
1404 info.gp = (sgot->output_section->vma
1405 + sgot->output_offset
1407 _bfd_set_gp_value (info.gotobj, info.gp);
1411 for (irel = internal_relocs; irel < irelend; irel++)
1414 Elf_Internal_Sym isym;
1415 struct alpha_elf_got_entry *gotent;
1417 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1420 /* Get the section contents. */
1421 if (info.contents == NULL)
1423 if (elf_section_data (sec)->this_hdr.contents != NULL)
1424 info.contents = elf_section_data (sec)->this_hdr.contents;
1427 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1428 if (info.contents == NULL)
1430 free_contents = info.contents;
1432 if (! bfd_get_section_contents (abfd, sec, info.contents,
1433 (file_ptr) 0, sec->_raw_size))
1438 /* Read this BFD's symbols if we haven't done so already. */
1439 if (extsyms == NULL)
1441 if (symtab_hdr->contents != NULL)
1442 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1445 extsyms = ((Elf64_External_Sym *)
1446 bfd_malloc (symtab_hdr->sh_size));
1447 if (extsyms == NULL)
1449 free_extsyms = extsyms;
1450 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1451 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1452 != symtab_hdr->sh_size))
1457 /* Get the value of the symbol referred to by the reloc. */
1458 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1460 /* A local symbol. */
1461 bfd_elf64_swap_symbol_in (abfd,
1462 extsyms + ELF64_R_SYM (irel->r_info),
1464 if (isym.st_shndx == SHN_UNDEF)
1465 info.tsec = bfd_und_section_ptr;
1466 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1467 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1468 else if (isym.st_shndx == SHN_ABS)
1469 info.tsec = bfd_abs_section_ptr;
1470 else if (isym.st_shndx == SHN_COMMON)
1471 info.tsec = bfd_com_section_ptr;
1473 continue; /* who knows. */
1476 info.other = isym.st_other;
1477 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1478 symval = isym.st_value;
1483 struct alpha_elf_link_hash_entry *h;
1485 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1486 h = alpha_elf_sym_hashes (abfd)[indx];
1487 BFD_ASSERT (h != NULL);
1489 while (h->root.root.type == bfd_link_hash_indirect
1490 || h->root.root.type == bfd_link_hash_warning)
1491 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1493 /* We can't do anthing with undefined or dynamic symbols. */
1494 if (h->root.root.type == bfd_link_hash_undefined
1495 || h->root.root.type == bfd_link_hash_undefweak
1496 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1500 info.tsec = h->root.root.u.def.section;
1501 info.other = h->root.other;
1502 gotent = h->got_entries;
1503 symval = h->root.root.u.def.value;
1506 /* Search for the got entry to be used by this relocation. */
1507 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1508 gotent = gotent->next;
1509 info.gotent = gotent;
1511 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1512 symval += irel->r_addend;
1514 BFD_ASSERT(info.gotent != NULL);
1516 /* If there exist LITUSE relocations immediately following, this
1517 opens up all sorts of interesting optimizations, because we
1518 now know every location that this address load is used. */
1520 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1522 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1528 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1533 if (!elf64_alpha_size_got_sections (abfd, link_info))
1536 if (info.changed_relocs)
1538 elf_section_data (sec)->relocs = internal_relocs;
1540 else if (free_relocs != NULL)
1545 if (info.changed_contents)
1547 elf_section_data (sec)->this_hdr.contents = info.contents;
1549 else if (free_contents != NULL)
1551 if (! link_info->keep_memory)
1552 free (free_contents);
1555 /* Cache the section contents for elf_link_input_bfd. */
1556 elf_section_data (sec)->this_hdr.contents = info.contents;
1560 if (free_extsyms != NULL)
1562 if (! link_info->keep_memory)
1563 free (free_extsyms);
1566 /* Cache the symbols for elf_link_input_bfd. */
1567 symtab_hdr->contents = extsyms;
1571 *again = info.changed_contents || info.changed_relocs;
1576 if (free_relocs != NULL)
1578 if (free_contents != NULL)
1579 free (free_contents);
1580 if (free_extsyms != NULL)
1581 free (free_extsyms);
1586 #define PLT_HEADER_SIZE 32
1587 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1588 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1589 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1590 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1592 #define PLT_ENTRY_SIZE 12
1593 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1594 #define PLT_ENTRY_WORD2 0
1595 #define PLT_ENTRY_WORD3 0
1597 #define MAX_GOT_ENTRIES (64*1024 / 8)
1599 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1601 /* Handle an Alpha specific section when reading an object file. This
1602 is called when elfcode.h finds a section with an unknown type.
1603 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1607 elf64_alpha_section_from_shdr (abfd, hdr, name)
1609 Elf64_Internal_Shdr *hdr;
1614 /* There ought to be a place to keep ELF backend specific flags, but
1615 at the moment there isn't one. We just keep track of the
1616 sections by their name, instead. Fortunately, the ABI gives
1617 suggested names for all the MIPS specific sections, so we will
1618 probably get away with this. */
1619 switch (hdr->sh_type)
1621 case SHT_ALPHA_DEBUG:
1622 if (strcmp (name, ".mdebug") != 0)
1625 #ifdef ERIC_neverdef
1626 case SHT_ALPHA_REGINFO:
1627 if (strcmp (name, ".reginfo") != 0
1628 || hdr->sh_size != sizeof (Elf64_External_RegInfo))
1636 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1638 newsect = hdr->bfd_section;
1640 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1642 if (! bfd_set_section_flags (abfd, newsect,
1643 (bfd_get_section_flags (abfd, newsect)
1648 #ifdef ERIC_neverdef
1649 /* For a .reginfo section, set the gp value in the tdata information
1650 from the contents of this section. We need the gp value while
1651 processing relocs, so we just get it now. */
1652 if (hdr->sh_type == SHT_ALPHA_REGINFO)
1654 Elf64_External_RegInfo ext;
1657 if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
1658 (file_ptr) 0, sizeof ext))
1660 bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
1661 elf_gp (abfd) = s.ri_gp_value;
1668 /* Set the correct type for an Alpha ELF section. We do this by the
1669 section name, which is a hack, but ought to work. */
1672 elf64_alpha_fake_sections (abfd, hdr, sec)
1674 Elf64_Internal_Shdr *hdr;
1677 register const char *name;
1679 name = bfd_get_section_name (abfd, sec);
1681 if (strcmp (name, ".mdebug") == 0)
1683 hdr->sh_type = SHT_ALPHA_DEBUG;
1684 /* In a shared object on Irix 5.3, the .mdebug section has an
1685 entsize of 0. FIXME: Does this matter? */
1686 if ((abfd->flags & DYNAMIC) != 0 )
1687 hdr->sh_entsize = 0;
1689 hdr->sh_entsize = 1;
1691 #ifdef ERIC_neverdef
1692 else if (strcmp (name, ".reginfo") == 0)
1694 hdr->sh_type = SHT_ALPHA_REGINFO;
1695 /* In a shared object on Irix 5.3, the .reginfo section has an
1696 entsize of 0x18. FIXME: Does this matter? */
1697 if ((abfd->flags & DYNAMIC) != 0)
1698 hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
1700 hdr->sh_entsize = 1;
1702 /* Force the section size to the correct value, even if the
1703 linker thinks it is larger. The link routine below will only
1704 write out this much data for .reginfo. */
1705 hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
1707 else if (strcmp (name, ".hash") == 0
1708 || strcmp (name, ".dynamic") == 0
1709 || strcmp (name, ".dynstr") == 0)
1711 hdr->sh_entsize = 0;
1712 hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
1715 else if (strcmp (name, ".sdata") == 0
1716 || strcmp (name, ".sbss") == 0
1717 || strcmp (name, ".lit4") == 0
1718 || strcmp (name, ".lit8") == 0)
1719 hdr->sh_flags |= SHF_ALPHA_GPREL;
1724 /* Hook called by the linker routine which adds symbols from an object
1725 file. We use it to put .comm items in .sbss, and not .bss. */
1728 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1730 struct bfd_link_info *info;
1731 const Elf_Internal_Sym *sym;
1732 const char **namep ATTRIBUTE_UNUSED;
1733 flagword *flagsp ATTRIBUTE_UNUSED;
1737 if (sym->st_shndx == SHN_COMMON
1738 && !info->relocateable
1739 && sym->st_size <= elf_gp_size (abfd))
1741 /* Common symbols less than or equal to -G nn bytes are
1742 automatically put into .sbss. */
1744 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1748 scomm = bfd_make_section (abfd, ".scommon");
1750 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1752 | SEC_LINKER_CREATED)))
1757 *valp = sym->st_size;
1763 /* Create the .got section. */
1766 elf64_alpha_create_got_section(abfd, info)
1768 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1772 if (bfd_get_section_by_name (abfd, ".got"))
1775 s = bfd_make_section (abfd, ".got");
1777 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1780 | SEC_LINKER_CREATED))
1781 || !bfd_set_section_alignment (abfd, s, 3))
1784 alpha_elf_tdata (abfd)->got = s;
1789 /* Create all the dynamic sections. */
1792 elf64_alpha_create_dynamic_sections (abfd, info)
1794 struct bfd_link_info *info;
1797 struct elf_link_hash_entry *h;
1799 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1801 s = bfd_make_section (abfd, ".plt");
1803 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1806 | SEC_LINKER_CREATED
1808 || ! bfd_set_section_alignment (abfd, s, 3))
1811 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1814 if (! (_bfd_generic_link_add_one_symbol
1815 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1816 (bfd_vma) 0, (const char *) NULL, false,
1817 get_elf_backend_data (abfd)->collect,
1818 (struct bfd_link_hash_entry **) &h)))
1820 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1821 h->type = STT_OBJECT;
1824 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1827 s = bfd_make_section (abfd, ".rela.plt");
1829 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1832 | SEC_LINKER_CREATED
1834 || ! bfd_set_section_alignment (abfd, s, 3))
1837 /* We may or may not have created a .got section for this object, but
1838 we definitely havn't done the rest of the work. */
1840 if (!elf64_alpha_create_got_section (abfd, info))
1843 s = bfd_make_section(abfd, ".rela.got");
1845 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1848 | SEC_LINKER_CREATED
1850 || !bfd_set_section_alignment (abfd, s, 3))
1853 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1854 dynobj's .got section. We don't do this in the linker script
1855 because we don't want to define the symbol if we are not creating
1856 a global offset table. */
1858 if (!(_bfd_generic_link_add_one_symbol
1859 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1860 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1861 false, get_elf_backend_data (abfd)->collect,
1862 (struct bfd_link_hash_entry **) &h)))
1864 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1865 h->type = STT_OBJECT;
1868 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1871 elf_hash_table (info)->hgot = h;
1876 /* Read ECOFF debugging information from a .mdebug section into a
1877 ecoff_debug_info structure. */
1880 elf64_alpha_read_ecoff_info (abfd, section, debug)
1883 struct ecoff_debug_info *debug;
1886 const struct ecoff_debug_swap *swap;
1887 char *ext_hdr = NULL;
1889 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1890 memset (debug, 0, sizeof (*debug));
1892 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
1893 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1896 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1897 swap->external_hdr_size)
1901 symhdr = &debug->symbolic_header;
1902 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1904 /* The symbolic header contains absolute file offsets and sizes to
1906 #define READ(ptr, offset, count, size, type) \
1907 if (symhdr->count == 0) \
1908 debug->ptr = NULL; \
1911 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
1912 if (debug->ptr == NULL) \
1913 goto error_return; \
1914 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1915 || (bfd_read (debug->ptr, size, symhdr->count, \
1916 abfd) != size * symhdr->count)) \
1917 goto error_return; \
1920 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1921 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1922 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1923 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1924 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1925 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1927 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1928 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1929 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1930 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1931 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1935 debug->adjust = NULL;
1940 if (ext_hdr != NULL)
1942 if (debug->line != NULL)
1944 if (debug->external_dnr != NULL)
1945 free (debug->external_dnr);
1946 if (debug->external_pdr != NULL)
1947 free (debug->external_pdr);
1948 if (debug->external_sym != NULL)
1949 free (debug->external_sym);
1950 if (debug->external_opt != NULL)
1951 free (debug->external_opt);
1952 if (debug->external_aux != NULL)
1953 free (debug->external_aux);
1954 if (debug->ss != NULL)
1956 if (debug->ssext != NULL)
1957 free (debug->ssext);
1958 if (debug->external_fdr != NULL)
1959 free (debug->external_fdr);
1960 if (debug->external_rfd != NULL)
1961 free (debug->external_rfd);
1962 if (debug->external_ext != NULL)
1963 free (debug->external_ext);
1967 /* Alpha ELF local labels start with '$'. */
1970 elf64_alpha_is_local_label_name (abfd, name)
1971 bfd *abfd ATTRIBUTE_UNUSED;
1974 return name[0] == '$';
1977 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1978 routine in order to handle the ECOFF debugging information. We
1979 still call this mips_elf_find_line because of the slot
1980 find_line_info in elf_obj_tdata is declared that way. */
1982 struct mips_elf_find_line
1984 struct ecoff_debug_info d;
1985 struct ecoff_find_line i;
1989 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
1990 functionname_ptr, line_ptr)
1995 const char **filename_ptr;
1996 const char **functionname_ptr;
1997 unsigned int *line_ptr;
2001 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2002 filename_ptr, functionname_ptr,
2004 &elf_tdata (abfd)->dwarf2_find_line_info))
2007 msec = bfd_get_section_by_name (abfd, ".mdebug");
2011 struct mips_elf_find_line *fi;
2012 const struct ecoff_debug_swap * const swap =
2013 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2015 /* If we are called during a link, alpha_elf_final_link may have
2016 cleared the SEC_HAS_CONTENTS field. We force it back on here
2017 if appropriate (which it normally will be). */
2018 origflags = msec->flags;
2019 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2020 msec->flags |= SEC_HAS_CONTENTS;
2022 fi = elf_tdata (abfd)->find_line_info;
2025 bfd_size_type external_fdr_size;
2028 struct fdr *fdr_ptr;
2030 fi = ((struct mips_elf_find_line *)
2031 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2034 msec->flags = origflags;
2038 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2040 msec->flags = origflags;
2044 /* Swap in the FDR information. */
2045 fi->d.fdr = ((struct fdr *)
2047 (fi->d.symbolic_header.ifdMax *
2048 sizeof (struct fdr))));
2049 if (fi->d.fdr == NULL)
2051 msec->flags = origflags;
2054 external_fdr_size = swap->external_fdr_size;
2055 fdr_ptr = fi->d.fdr;
2056 fraw_src = (char *) fi->d.external_fdr;
2057 fraw_end = (fraw_src
2058 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2059 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2060 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2062 elf_tdata (abfd)->find_line_info = fi;
2064 /* Note that we don't bother to ever free this information.
2065 find_nearest_line is either called all the time, as in
2066 objdump -l, so the information should be saved, or it is
2067 rarely called, as in ld error messages, so the memory
2068 wasted is unimportant. Still, it would probably be a
2069 good idea for free_cached_info to throw it away. */
2072 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2073 &fi->i, filename_ptr, functionname_ptr,
2076 msec->flags = origflags;
2080 msec->flags = origflags;
2083 /* Fall back on the generic ELF find_nearest_line routine. */
2085 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2086 filename_ptr, functionname_ptr,
2090 /* Structure used to pass information to alpha_elf_output_extsym. */
2095 struct bfd_link_info *info;
2096 struct ecoff_debug_info *debug;
2097 const struct ecoff_debug_swap *swap;
2102 elf64_alpha_output_extsym (h, data)
2103 struct alpha_elf_link_hash_entry *h;
2106 struct extsym_info *einfo = (struct extsym_info *) data;
2108 asection *sec, *output_section;
2110 if (h->root.indx == -2)
2112 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2113 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2114 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2115 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2117 else if (einfo->info->strip == strip_all
2118 || (einfo->info->strip == strip_some
2119 && bfd_hash_lookup (einfo->info->keep_hash,
2120 h->root.root.root.string,
2121 false, false) == NULL))
2129 if (h->esym.ifd == -2)
2132 h->esym.cobol_main = 0;
2133 h->esym.weakext = 0;
2134 h->esym.reserved = 0;
2135 h->esym.ifd = ifdNil;
2136 h->esym.asym.value = 0;
2137 h->esym.asym.st = stGlobal;
2139 if (h->root.root.type != bfd_link_hash_defined
2140 && h->root.root.type != bfd_link_hash_defweak)
2141 h->esym.asym.sc = scAbs;
2146 sec = h->root.root.u.def.section;
2147 output_section = sec->output_section;
2149 /* When making a shared library and symbol h is the one from
2150 the another shared library, OUTPUT_SECTION may be null. */
2151 if (output_section == NULL)
2152 h->esym.asym.sc = scUndefined;
2155 name = bfd_section_name (output_section->owner, output_section);
2157 if (strcmp (name, ".text") == 0)
2158 h->esym.asym.sc = scText;
2159 else if (strcmp (name, ".data") == 0)
2160 h->esym.asym.sc = scData;
2161 else if (strcmp (name, ".sdata") == 0)
2162 h->esym.asym.sc = scSData;
2163 else if (strcmp (name, ".rodata") == 0
2164 || strcmp (name, ".rdata") == 0)
2165 h->esym.asym.sc = scRData;
2166 else if (strcmp (name, ".bss") == 0)
2167 h->esym.asym.sc = scBss;
2168 else if (strcmp (name, ".sbss") == 0)
2169 h->esym.asym.sc = scSBss;
2170 else if (strcmp (name, ".init") == 0)
2171 h->esym.asym.sc = scInit;
2172 else if (strcmp (name, ".fini") == 0)
2173 h->esym.asym.sc = scFini;
2175 h->esym.asym.sc = scAbs;
2179 h->esym.asym.reserved = 0;
2180 h->esym.asym.index = indexNil;
2183 if (h->root.root.type == bfd_link_hash_common)
2184 h->esym.asym.value = h->root.root.u.c.size;
2185 else if (h->root.root.type == bfd_link_hash_defined
2186 || h->root.root.type == bfd_link_hash_defweak)
2188 if (h->esym.asym.sc == scCommon)
2189 h->esym.asym.sc = scBss;
2190 else if (h->esym.asym.sc == scSCommon)
2191 h->esym.asym.sc = scSBss;
2193 sec = h->root.root.u.def.section;
2194 output_section = sec->output_section;
2195 if (output_section != NULL)
2196 h->esym.asym.value = (h->root.root.u.def.value
2197 + sec->output_offset
2198 + output_section->vma);
2200 h->esym.asym.value = 0;
2202 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2204 /* Set type and value for a symbol with a function stub. */
2205 h->esym.asym.st = stProc;
2206 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2208 h->esym.asym.value = 0;
2211 output_section = sec->output_section;
2212 if (output_section != NULL)
2213 h->esym.asym.value = (h->root.plt.offset
2214 + sec->output_offset
2215 + output_section->vma);
2217 h->esym.asym.value = 0;
2224 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2225 h->root.root.root.string,
2228 einfo->failed = true;
2235 /* FIXME: Create a runtime procedure table from the .mdebug section.
2238 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2241 struct bfd_link_info *info;
2243 struct ecoff_debug_info *debug;
2246 /* Handle dynamic relocations when doing an Alpha ELF link. */
2249 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2251 struct bfd_link_info *info;
2253 const Elf_Internal_Rela *relocs;
2257 const char *rel_sec_name;
2258 Elf_Internal_Shdr *symtab_hdr;
2259 struct alpha_elf_link_hash_entry **sym_hashes;
2260 struct alpha_elf_got_entry **local_got_entries;
2261 const Elf_Internal_Rela *rel, *relend;
2264 if (info->relocateable)
2267 dynobj = elf_hash_table(info)->dynobj;
2269 elf_hash_table(info)->dynobj = dynobj = abfd;
2272 rel_sec_name = NULL;
2273 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2274 sym_hashes = alpha_elf_sym_hashes(abfd);
2275 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2278 relend = relocs + sec->reloc_count;
2279 for (rel = relocs; rel < relend; ++rel)
2281 unsigned long r_symndx, r_type;
2282 struct alpha_elf_link_hash_entry *h;
2284 r_symndx = ELF64_R_SYM (rel->r_info);
2285 if (r_symndx < symtab_hdr->sh_info)
2289 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2291 while (h->root.root.type == bfd_link_hash_indirect
2292 || h->root.root.type == bfd_link_hash_warning)
2293 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2295 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2297 r_type = ELF64_R_TYPE (rel->r_info);
2301 case R_ALPHA_LITERAL:
2303 struct alpha_elf_got_entry *gotent;
2308 /* Search for and possibly create a got entry. */
2309 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2310 if (gotent->gotobj == abfd &&
2311 gotent->addend == rel->r_addend)
2316 gotent = ((struct alpha_elf_got_entry *)
2318 sizeof (struct alpha_elf_got_entry)));
2322 gotent->gotobj = abfd;
2323 gotent->addend = rel->r_addend;
2324 gotent->got_offset = -1;
2326 gotent->use_count = 1;
2328 gotent->next = h->got_entries;
2329 h->got_entries = gotent;
2331 alpha_elf_tdata (abfd)->total_got_entries++;
2334 gotent->use_count += 1;
2338 /* This is a local .got entry -- record for merge. */
2339 if (!local_got_entries)
2342 size = (symtab_hdr->sh_info
2343 * sizeof (struct alpha_elf_got_entry *));
2345 local_got_entries = ((struct alpha_elf_got_entry **)
2346 bfd_alloc (abfd, size));
2347 if (!local_got_entries)
2350 memset (local_got_entries, 0, size);
2351 alpha_elf_tdata (abfd)->local_got_entries =
2355 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2356 gotent != NULL && gotent->addend != rel->r_addend;
2357 gotent = gotent->next)
2361 gotent = ((struct alpha_elf_got_entry *)
2363 sizeof (struct alpha_elf_got_entry)));
2367 gotent->gotobj = abfd;
2368 gotent->addend = rel->r_addend;
2369 gotent->got_offset = -1;
2371 gotent->use_count = 1;
2373 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2374 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2376 alpha_elf_tdata(abfd)->total_got_entries++;
2377 alpha_elf_tdata(abfd)->n_local_got_entries++;
2380 gotent->use_count += 1;
2383 /* Remember how this literal is used from its LITUSEs.
2384 This will be important when it comes to decide if we can
2385 create a .plt entry for a function symbol. */
2387 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2392 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2393 flags |= 1 << rel->r_addend;
2395 while (rel+1 < relend &&
2396 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2400 /* No LITUSEs -- presumably the address is not being
2401 loaded for nothing. */
2402 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2405 gotent->flags |= flags;
2408 /* Make a guess as to whether a .plt entry will be needed. */
2409 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2410 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2412 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2417 case R_ALPHA_GPDISP:
2418 case R_ALPHA_GPREL16:
2419 case R_ALPHA_GPREL32:
2420 case R_ALPHA_GPRELHIGH:
2421 case R_ALPHA_GPRELLOW:
2422 /* We don't actually use the .got here, but the sections must
2423 be created before the linker maps input sections to output
2427 if (!elf64_alpha_create_got_section (abfd, info))
2430 /* Make sure the object's gotobj is set to itself so
2431 that we default to every object with its own .got.
2432 We'll merge .gots later once we've collected each
2434 alpha_elf_tdata(abfd)->gotobj = abfd;
2440 case R_ALPHA_SREL16:
2441 case R_ALPHA_SREL32:
2442 case R_ALPHA_SREL64:
2447 case R_ALPHA_REFLONG:
2448 case R_ALPHA_REFQUAD:
2449 if (rel_sec_name == NULL)
2451 rel_sec_name = (bfd_elf_string_from_elf_section
2452 (abfd, elf_elfheader(abfd)->e_shstrndx,
2453 elf_section_data(sec)->rel_hdr.sh_name));
2454 if (rel_sec_name == NULL)
2457 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2458 && strcmp (bfd_get_section_name (abfd, sec),
2459 rel_sec_name+5) == 0);
2462 /* We need to create the section here now whether we eventually
2463 use it or not so that it gets mapped to an output section by
2464 the linker. If not used, we'll kill it in
2465 size_dynamic_sections. */
2468 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2471 sreloc = bfd_make_section (dynobj, rel_sec_name);
2473 || !bfd_set_section_flags (dynobj, sreloc,
2480 | SEC_LINKER_CREATED
2482 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2489 /* Since we havn't seen all of the input symbols yet, we
2490 don't know whether we'll actually need a dynamic relocation
2491 entry for this reloc. So make a record of it. Once we
2492 find out if this thing needs dynamic relocation we'll
2493 expand the relocation sections by the appropriate amount. */
2495 struct alpha_elf_reloc_entry *rent;
2497 for (rent = h->reloc_entries; rent; rent = rent->next)
2498 if (rent->rtype == r_type && rent->srel == sreloc)
2503 rent = ((struct alpha_elf_reloc_entry *)
2505 sizeof (struct alpha_elf_reloc_entry)));
2509 rent->srel = sreloc;
2510 rent->rtype = r_type;
2512 rent->reltext = (sec->flags & SEC_READONLY) != 0;
2514 rent->next = h->reloc_entries;
2515 h->reloc_entries = rent;
2520 else if (info->shared && (sec->flags & SEC_ALLOC))
2522 /* If this is a shared library, and the section is to be
2523 loaded into memory, we need a RELATIVE reloc. */
2524 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2525 if (sec->flags & SEC_READONLY)
2526 info->flags |= DF_TEXTREL;
2535 /* Adjust a symbol defined by a dynamic object and referenced by a
2536 regular object. The current definition is in some section of the
2537 dynamic object, but we're not including those sections. We have to
2538 change the definition to something the rest of the link can
2542 elf64_alpha_adjust_dynamic_symbol (info, h)
2543 struct bfd_link_info *info;
2544 struct elf_link_hash_entry *h;
2548 struct alpha_elf_link_hash_entry *ah;
2550 dynobj = elf_hash_table(info)->dynobj;
2551 ah = (struct alpha_elf_link_hash_entry *)h;
2553 /* Now that we've seen all of the input symbols, finalize our decision
2554 about whether this symbol should get a .plt entry. */
2556 if (h->root.type != bfd_link_hash_undefweak
2557 && alpha_elf_dynamic_symbol_p (h, info)
2558 && ((h->type == STT_FUNC
2559 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2560 || (h->type == STT_NOTYPE
2561 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2562 /* Don't prevent otherwise valid programs from linking by attempting
2563 to create a new .got entry somewhere. A Correct Solution would be
2564 to add a new .got section to a new object file and let it be merged
2565 somewhere later. But for now don't bother. */
2568 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2570 s = bfd_get_section_by_name(dynobj, ".plt");
2571 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2574 /* The first bit of the .plt is reserved. */
2575 if (s->_raw_size == 0)
2576 s->_raw_size = PLT_HEADER_SIZE;
2578 h->plt.offset = s->_raw_size;
2579 s->_raw_size += PLT_ENTRY_SIZE;
2581 /* If this symbol is not defined in a regular file, and we are not
2582 generating a shared library, then set the symbol to the location
2583 in the .plt. This is required to make function pointers compare
2584 equal between the normal executable and the shared library. */
2586 && h->root.type != bfd_link_hash_defweak)
2588 h->root.u.def.section = s;
2589 h->root.u.def.value = h->plt.offset;
2592 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2593 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2594 BFD_ASSERT (s != NULL);
2595 s->_raw_size += sizeof (Elf64_External_Rela);
2600 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2602 /* If this is a weak symbol, and there is a real definition, the
2603 processor independent code will have arranged for us to see the
2604 real definition first, and we can just use the same value. */
2605 if (h->weakdef != NULL)
2607 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2608 || h->weakdef->root.type == bfd_link_hash_defweak);
2609 h->root.u.def.section = h->weakdef->root.u.def.section;
2610 h->root.u.def.value = h->weakdef->root.u.def.value;
2614 /* This is a reference to a symbol defined by a dynamic object which
2615 is not a function. The Alpha, since it uses .got entries for all
2616 symbols even in regular objects, does not need the hackery of a
2617 .dynbss section and COPY dynamic relocations. */
2622 /* Symbol versioning can create new symbols, and make our old symbols
2623 indirect to the new ones. Consolidate the got and reloc information
2624 in these situations. */
2627 elf64_alpha_merge_ind_symbols (hi, dummy)
2628 struct alpha_elf_link_hash_entry *hi;
2629 PTR dummy ATTRIBUTE_UNUSED;
2631 struct alpha_elf_link_hash_entry *hs;
2633 if (hi->root.root.type != bfd_link_hash_indirect)
2637 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2638 } while (hs->root.root.type == bfd_link_hash_indirect);
2640 /* Merge the flags. Whee. */
2642 hs->flags |= hi->flags;
2644 /* Merge the .got entries. Cannibalize the old symbol's list in
2645 doing so, since we don't need it anymore. */
2647 if (hs->got_entries == NULL)
2648 hs->got_entries = hi->got_entries;
2651 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2653 gsh = hs->got_entries;
2654 for (gi = hi->got_entries; gi ; gi = gin)
2657 for (gs = gsh; gs ; gs = gs->next)
2658 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2660 gi->next = hs->got_entries;
2661 hs->got_entries = gi;
2665 hi->got_entries = NULL;
2667 /* And similar for the reloc entries. */
2669 if (hs->reloc_entries == NULL)
2670 hs->reloc_entries = hi->reloc_entries;
2673 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2675 rsh = hs->reloc_entries;
2676 for (ri = hi->reloc_entries; ri ; ri = rin)
2679 for (rs = rsh; rs ; rs = rs->next)
2680 if (ri->rtype == rs->rtype)
2682 rs->count += ri->count;
2685 ri->next = hs->reloc_entries;
2686 hs->reloc_entries = ri;
2690 hi->reloc_entries = NULL;
2695 /* Is it possible to merge two object file's .got tables? */
2698 elf64_alpha_can_merge_gots (a, b)
2701 int total = alpha_elf_tdata (a)->total_got_entries;
2704 /* Trivial quick fallout test. */
2705 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2708 /* By their nature, local .got entries cannot be merged. */
2709 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2712 /* Failing the common trivial comparison, we must effectively
2713 perform the merge. Not actually performing the merge means that
2714 we don't have to store undo information in case we fail. */
2715 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2717 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2718 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2721 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2722 for (i = 0; i < n; ++i)
2724 struct alpha_elf_got_entry *ae, *be;
2725 struct alpha_elf_link_hash_entry *h;
2728 while (h->root.root.type == bfd_link_hash_indirect
2729 || h->root.root.type == bfd_link_hash_warning)
2730 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2732 for (be = h->got_entries; be ; be = be->next)
2734 if (be->use_count == 0)
2736 if (be->gotobj != b)
2739 for (ae = h->got_entries; ae ; ae = ae->next)
2740 if (ae->gotobj == a && ae->addend == be->addend)
2743 if (++total > MAX_GOT_ENTRIES)
2753 /* Actually merge two .got tables. */
2756 elf64_alpha_merge_gots (a, b)
2759 int total = alpha_elf_tdata (a)->total_got_entries;
2762 /* Remember local expansion. */
2764 int e = alpha_elf_tdata (b)->n_local_got_entries;
2766 alpha_elf_tdata (a)->n_local_got_entries += e;
2769 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2771 struct alpha_elf_got_entry **local_got_entries;
2772 struct alpha_elf_link_hash_entry **hashes;
2773 Elf_Internal_Shdr *symtab_hdr;
2776 /* Let the local .got entries know they are part of a new subsegment. */
2777 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2778 if (local_got_entries)
2780 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2781 for (i = 0; i < n; ++i)
2783 struct alpha_elf_got_entry *ent;
2784 for (ent = local_got_entries[i]; ent; ent = ent->next)
2789 /* Merge the global .got entries. */
2790 hashes = alpha_elf_sym_hashes (bsub);
2791 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2793 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2794 for (i = 0; i < n; ++i)
2796 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2797 struct alpha_elf_link_hash_entry *h;
2800 while (h->root.root.type == bfd_link_hash_indirect
2801 || h->root.root.type == bfd_link_hash_warning)
2802 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2804 start = &h->got_entries;
2805 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2807 if (be->use_count == 0)
2812 if (be->gotobj != b)
2815 for (ae = *start; ae ; ae = ae->next)
2816 if (ae->gotobj == a && ae->addend == be->addend)
2818 ae->flags |= be->flags;
2819 ae->use_count += be->use_count;
2830 alpha_elf_tdata (bsub)->gotobj = a;
2832 alpha_elf_tdata (a)->total_got_entries = total;
2834 /* Merge the two in_got chains. */
2839 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2842 alpha_elf_tdata (bsub)->in_got_link_next = b;
2846 /* Calculate the offsets for the got entries. */
2849 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2850 struct alpha_elf_link_hash_entry *h;
2851 PTR arg ATTRIBUTE_UNUSED;
2853 struct alpha_elf_got_entry *gotent;
2855 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2856 if (gotent->use_count > 0)
2859 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2861 gotent->got_offset = *plge;
2869 elf64_alpha_calc_got_offsets (info)
2870 struct bfd_link_info *info;
2872 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2874 /* First, zero out the .got sizes, as we may be recalculating the
2875 .got after optimizing it. */
2876 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2877 alpha_elf_tdata(i)->got->_raw_size = 0;
2879 /* Next, fill in the offsets for all the global entries. */
2880 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2881 elf64_alpha_calc_got_offsets_for_symbol,
2884 /* Finally, fill in the offsets for the local entries. */
2885 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2887 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2890 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2892 struct alpha_elf_got_entry **local_got_entries, *gotent;
2895 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2896 if (!local_got_entries)
2899 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2900 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2901 if (gotent->use_count > 0)
2903 gotent->got_offset = got_offset;
2908 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2909 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2913 /* Constructs the gots. */
2916 elf64_alpha_size_got_sections (output_bfd, info)
2917 bfd *output_bfd ATTRIBUTE_UNUSED;
2918 struct bfd_link_info *info;
2920 bfd *i, *got_list, *cur_got_obj = NULL;
2921 int something_changed = 0;
2923 got_list = alpha_elf_hash_table (info)->got_list;
2925 /* On the first time through, pretend we have an existing got list
2926 consisting of all of the input files. */
2927 if (got_list == NULL)
2929 for (i = info->input_bfds; i ; i = i->link_next)
2931 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2932 if (this_got == NULL)
2935 /* We are assuming no merging has yet ocurred. */
2936 BFD_ASSERT (this_got == i);
2938 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2940 /* Yikes! A single object file has too many entries. */
2941 (*_bfd_error_handler)
2942 (_("%s: .got subsegment exceeds 64K (size %d)"),
2943 bfd_get_filename (i),
2944 alpha_elf_tdata (this_got)->total_got_entries * 8);
2948 if (got_list == NULL)
2949 got_list = this_got;
2951 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2952 cur_got_obj = this_got;
2955 /* Strange degenerate case of no got references. */
2956 if (got_list == NULL)
2959 alpha_elf_hash_table (info)->got_list = got_list;
2961 /* Force got offsets to be recalculated. */
2962 something_changed = 1;
2965 cur_got_obj = got_list;
2966 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2969 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2971 elf64_alpha_merge_gots (cur_got_obj, i);
2972 i = alpha_elf_tdata(i)->got_link_next;
2973 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2974 something_changed = 1;
2979 i = alpha_elf_tdata(i)->got_link_next;
2983 /* Once the gots have been merged, fill in the got offsets for
2984 everything therein. */
2985 if (1 || something_changed)
2986 elf64_alpha_calc_got_offsets (info);
2992 elf64_alpha_always_size_sections (output_bfd, info)
2994 struct bfd_link_info *info;
2998 if (info->relocateable)
3001 /* First, take care of the indirect symbols created by versioning. */
3002 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3003 elf64_alpha_merge_ind_symbols,
3006 if (!elf64_alpha_size_got_sections (output_bfd, info))
3009 /* Allocate space for all of the .got subsections. */
3010 i = alpha_elf_hash_table (info)->got_list;
3011 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3013 asection *s = alpha_elf_tdata(i)->got;
3014 if (s->_raw_size > 0)
3016 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3017 if (s->contents == NULL)
3025 /* Work out the sizes of the dynamic relocation entries. */
3028 elf64_alpha_calc_dynrel_sizes (h, info)
3029 struct alpha_elf_link_hash_entry *h;
3030 struct bfd_link_info *info;
3032 /* If the symbol was defined as a common symbol in a regular object
3033 file, and there was no definition in any dynamic object, then the
3034 linker will have allocated space for the symbol in a common
3035 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3036 set. This is done for dynamic symbols in
3037 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3038 symbols, somehow. */
3039 if (((h->root.elf_link_hash_flags
3040 & (ELF_LINK_HASH_DEF_REGULAR
3041 | ELF_LINK_HASH_REF_REGULAR
3042 | ELF_LINK_HASH_DEF_DYNAMIC))
3043 == ELF_LINK_HASH_REF_REGULAR)
3044 && (h->root.root.type == bfd_link_hash_defined
3045 || h->root.root.type == bfd_link_hash_defweak)
3046 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3048 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3051 /* If the symbol is dynamic, we'll need all the relocations in their
3052 natural form. If this is a shared object, and it has been forced
3053 local, we'll need the same number of RELATIVE relocations. */
3055 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3057 struct alpha_elf_reloc_entry *relent;
3059 struct alpha_elf_got_entry *gotent;
3060 bfd_size_type count;
3063 for (relent = h->reloc_entries; relent; relent = relent->next)
3064 if (relent->rtype == R_ALPHA_REFLONG
3065 || relent->rtype == R_ALPHA_REFQUAD)
3067 relent->srel->_raw_size +=
3068 sizeof (Elf64_External_Rela) * relent->count;
3069 if (relent->reltext)
3070 info->flags |= DT_TEXTREL;
3073 dynobj = elf_hash_table(info)->dynobj;
3076 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3079 /* If we are using a .plt entry, subtract one, as the first
3080 reference uses a .rela.plt entry instead. */
3081 if (h->root.plt.offset != MINUS_ONE)
3086 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3087 BFD_ASSERT (srel != NULL);
3088 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3095 /* Set the sizes of the dynamic sections. */
3098 elf64_alpha_size_dynamic_sections (output_bfd, info)
3099 bfd *output_bfd ATTRIBUTE_UNUSED;
3100 struct bfd_link_info *info;
3106 dynobj = elf_hash_table(info)->dynobj;
3107 BFD_ASSERT(dynobj != NULL);
3109 if (elf_hash_table (info)->dynamic_sections_created)
3111 /* Set the contents of the .interp section to the interpreter. */
3114 s = bfd_get_section_by_name (dynobj, ".interp");
3115 BFD_ASSERT (s != NULL);
3116 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3117 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3120 /* Now that we've seen all of the input files, we can decide which
3121 symbols need dynamic relocation entries and which don't. We've
3122 collected information in check_relocs that we can now apply to
3123 size the dynamic relocation sections. */
3124 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3125 elf64_alpha_calc_dynrel_sizes,
3128 /* When building shared libraries, each local .got entry needs a
3134 bfd_size_type count;
3136 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3137 BFD_ASSERT (srel != NULL);
3139 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3141 i = alpha_elf_tdata(i)->got_link_next)
3142 count += alpha_elf_tdata(i)->n_local_got_entries;
3144 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3147 /* else we're not dynamic and by definition we don't need such things. */
3149 /* The check_relocs and adjust_dynamic_symbol entry points have
3150 determined the sizes of the various dynamic sections. Allocate
3153 for (s = dynobj->sections; s != NULL; s = s->next)
3158 if (!(s->flags & SEC_LINKER_CREATED))
3161 /* It's OK to base decisions on the section name, because none
3162 of the dynobj section names depend upon the input files. */
3163 name = bfd_get_section_name (dynobj, s);
3165 /* If we don't need this section, strip it from the output file.
3166 This is to handle .rela.bss and .rela.plt. We must create it
3167 in create_dynamic_sections, because it must be created before
3168 the linker maps input sections to output sections. The
3169 linker does that before adjust_dynamic_symbol is called, and
3170 it is that function which decides whether anything needs to
3171 go into these sections. */
3175 if (strncmp (name, ".rela", 5) == 0)
3177 strip = (s->_raw_size == 0);
3181 if (strcmp(name, ".rela.plt") == 0)
3184 /* We use the reloc_count field as a counter if we need
3185 to copy relocs into the output file. */
3189 else if (strcmp (name, ".plt") != 0)
3191 /* It's not one of our dynamic sections, so don't allocate space. */
3196 _bfd_strip_section_from_output (info, s);
3199 /* Allocate memory for the section contents. */
3200 s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3201 if (s->contents == NULL && s->_raw_size != 0)
3206 if (elf_hash_table (info)->dynamic_sections_created)
3208 /* Add some entries to the .dynamic section. We fill in the
3209 values later, in elf64_alpha_finish_dynamic_sections, but we
3210 must add the entries now so that we get the correct size for
3211 the .dynamic section. The DT_DEBUG entry is filled in by the
3212 dynamic linker and used by the debugger. */
3215 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3219 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3224 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3225 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3226 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3230 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3231 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3232 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3233 sizeof (Elf64_External_Rela)))
3236 if (info->flags & DF_TEXTREL)
3238 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3246 /* Relocate an Alpha ELF section. */
3249 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3250 contents, relocs, local_syms, local_sections)
3252 struct bfd_link_info *info;
3254 asection *input_section;
3256 Elf_Internal_Rela *relocs;
3257 Elf_Internal_Sym *local_syms;
3258 asection **local_sections;
3260 Elf_Internal_Shdr *symtab_hdr;
3261 Elf_Internal_Rela *rel;
3262 Elf_Internal_Rela *relend;
3263 asection *sec, *sgot, *srel, *srelgot;
3264 bfd *dynobj, *gotobj;
3266 boolean ret_val = true;
3268 srelgot = srel = NULL;
3269 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3270 dynobj = elf_hash_table (info)->dynobj;
3273 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3276 /* Find the gp value for this input bfd. */
3279 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3282 sgot = alpha_elf_tdata (gotobj)->got;
3283 gp = _bfd_get_gp_value (gotobj);
3286 gp = (sgot->output_section->vma
3287 + sgot->output_offset
3289 _bfd_set_gp_value (gotobj, gp);
3294 relend = relocs + input_section->reloc_count;
3295 for (; rel < relend; rel++)
3298 reloc_howto_type *howto;
3299 unsigned long r_symndx;
3300 struct alpha_elf_link_hash_entry *h;
3301 Elf_Internal_Sym *sym;
3303 bfd_signed_vma addend;
3304 bfd_reloc_status_type r;
3306 r_type = ELF64_R_TYPE(rel->r_info);
3307 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3309 bfd_set_error (bfd_error_bad_value);
3312 howto = elf64_alpha_howto_table + r_type;
3314 r_symndx = ELF64_R_SYM(rel->r_info);
3316 if (info->relocateable)
3318 /* This is a relocateable link. We don't have to change
3319 anything, unless the reloc is against a section symbol,
3320 in which case we have to adjust according to where the
3321 section symbol winds up in the output section. */
3323 /* The symbol associated with GPDISP and LITUSE is
3324 immaterial. Only the addend is significant. */
3325 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3328 if (r_symndx < symtab_hdr->sh_info)
3330 sym = local_syms + r_symndx;
3331 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3333 sec = local_sections[r_symndx];
3334 rel->r_addend += sec->output_offset + sym->st_value;
3341 /* This is a final link. */
3347 if (r_symndx < symtab_hdr->sh_info)
3349 sym = local_syms + r_symndx;
3350 sec = local_sections[r_symndx];
3351 relocation = (sec->output_section->vma
3352 + sec->output_offset
3357 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3359 while (h->root.root.type == bfd_link_hash_indirect
3360 || h->root.root.type == bfd_link_hash_warning)
3361 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3363 if (h->root.root.type == bfd_link_hash_defined
3364 || h->root.root.type == bfd_link_hash_defweak)
3366 sec = h->root.root.u.def.section;
3369 if ((r_type == R_ALPHA_LITERAL
3370 && elf_hash_table(info)->dynamic_sections_created
3373 || !(h->root.elf_link_hash_flags
3374 & ELF_LINK_HASH_DEF_REGULAR)))
3377 || !(h->root.elf_link_hash_flags
3378 & ELF_LINK_HASH_DEF_REGULAR))
3379 && (input_section->flags & SEC_ALLOC)
3380 && (r_type == R_ALPHA_REFLONG
3381 || r_type == R_ALPHA_REFQUAD
3382 || r_type == R_ALPHA_LITERAL)))
3384 /* In these cases, we don't need the relocation value.
3385 We check specially because in some obscure cases
3386 sec->output_section will be NULL. */
3390 /* FIXME: Are not these obscure cases simply bugs? Let's
3391 get something working and come back to this. */
3392 if (sec->output_section == NULL)
3394 #endif /* rth_notdef */
3397 relocation = (h->root.root.u.def.value
3398 + sec->output_section->vma
3399 + sec->output_offset);
3402 else if (h->root.root.type == bfd_link_hash_undefweak)
3404 else if (info->shared && !info->symbolic
3405 && !info->no_undefined
3406 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3410 if (!((*info->callbacks->undefined_symbol)
3411 (info, h->root.root.root.string, input_bfd,
3412 input_section, rel->r_offset,
3413 (!info->shared || info->no_undefined
3414 || ELF_ST_VISIBILITY (h->root.other)))))
3419 addend = rel->r_addend;
3423 case R_ALPHA_GPDISP:
3425 bfd_byte *p_ldah, *p_lda;
3427 BFD_ASSERT(gp != 0);
3429 relocation = (input_section->output_section->vma
3430 + input_section->output_offset
3433 p_ldah = contents + rel->r_offset - input_section->vma;
3434 p_lda = p_ldah + rel->r_addend;
3436 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3441 case R_ALPHA_LITERAL:
3443 struct alpha_elf_got_entry *gotent;
3444 boolean dynamic_symbol;
3446 BFD_ASSERT(sgot != NULL);
3447 BFD_ASSERT(gp != 0);
3451 gotent = h->got_entries;
3452 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3456 gotent = (alpha_elf_tdata(input_bfd)->
3457 local_got_entries[r_symndx]);
3458 dynamic_symbol = false;
3461 BFD_ASSERT(gotent != NULL);
3463 while (gotent->gotobj != gotobj || gotent->addend != addend)
3464 gotent = gotent->next;
3466 BFD_ASSERT(gotent->use_count >= 1);
3468 /* Initialize the .got entry's value. */
3469 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3471 bfd_put_64 (output_bfd, relocation+addend,
3472 sgot->contents + gotent->got_offset);
3474 /* If the symbol has been forced local, output a
3475 RELATIVE reloc, otherwise it will be handled in
3476 finish_dynamic_symbol. */
3477 if (info->shared && !dynamic_symbol)
3479 Elf_Internal_Rela outrel;
3481 BFD_ASSERT(srelgot != NULL);
3483 outrel.r_offset = (sgot->output_section->vma
3484 + sgot->output_offset
3485 + gotent->got_offset);
3486 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3487 outrel.r_addend = relocation+addend;
3489 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3490 ((Elf64_External_Rela *)
3492 + srelgot->reloc_count++);
3493 BFD_ASSERT (sizeof (Elf64_External_Rela)
3494 * srelgot->reloc_count
3495 <= srelgot->_cooked_size);
3498 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3501 /* Figure the gprel relocation. */
3503 relocation = (sgot->output_section->vma
3504 + sgot->output_offset
3505 + gotent->got_offset);
3508 /* overflow handled by _bfd_final_link_relocate */
3511 case R_ALPHA_GPREL16:
3512 case R_ALPHA_GPREL32:
3513 case R_ALPHA_GPRELLOW:
3514 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3516 (*_bfd_error_handler)
3517 (_("%s: gp-relative relocation against dynamic symbol %s"),
3518 bfd_get_filename (input_bfd), h->root.root.root.string);
3521 BFD_ASSERT(gp != 0);
3525 case R_ALPHA_GPRELHIGH:
3526 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3528 (*_bfd_error_handler)
3529 (_("%s: gp-relative relocation against dynamic symbol %s"),
3530 bfd_get_filename (input_bfd), h->root.root.root.string);
3533 BFD_ASSERT(gp != 0);
3535 relocation += addend;
3537 relocation = (((bfd_signed_vma) relocation >> 16)
3538 + ((relocation >> 15) & 1));
3541 case R_ALPHA_BRADDR:
3543 /* The regular PC-relative stuff measures from the start of
3544 the instruction rather than the end. */
3548 case R_ALPHA_REFLONG:
3549 case R_ALPHA_REFQUAD:
3551 Elf_Internal_Rela outrel;
3554 /* Careful here to remember RELATIVE relocations for global
3555 variables for symbolic shared objects. */
3557 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3559 BFD_ASSERT(h->root.dynindx != -1);
3560 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3561 outrel.r_addend = addend;
3562 addend = 0, relocation = 0;
3564 else if (info->shared && (input_section->flags & SEC_ALLOC))
3566 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3567 outrel.r_addend = relocation + addend;
3576 name = (bfd_elf_string_from_elf_section
3577 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3578 elf_section_data(input_section)->rel_hdr.sh_name));
3579 BFD_ASSERT(name != NULL);
3581 srel = bfd_get_section_by_name (dynobj, name);
3582 BFD_ASSERT(srel != NULL);
3587 if (elf_section_data (input_section)->stab_info == NULL)
3588 outrel.r_offset = rel->r_offset;
3593 off = (_bfd_stab_section_offset
3594 (output_bfd, &elf_hash_table (info)->stab_info,
3596 &elf_section_data (input_section)->stab_info,
3598 if (off == (bfd_vma) -1)
3600 outrel.r_offset = off;
3604 outrel.r_offset += (input_section->output_section->vma
3605 + input_section->output_offset);
3607 memset (&outrel, 0, sizeof outrel);
3609 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3610 ((Elf64_External_Rela *)
3612 + srel->reloc_count++);
3613 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3614 <= srel->_cooked_size);
3620 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3621 contents, rel->r_offset, relocation,
3631 case bfd_reloc_overflow:
3636 name = h->root.root.root.string;
3639 name = (bfd_elf_string_from_elf_section
3640 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3644 name = bfd_section_name (input_bfd, sec);
3646 if (! ((*info->callbacks->reloc_overflow)
3647 (info, name, howto->name, (bfd_vma) 0,
3648 input_bfd, input_section, rel->r_offset)))
3654 case bfd_reloc_outofrange:
3662 /* Finish up dynamic symbol handling. We set the contents of various
3663 dynamic sections here. */
3666 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3668 struct bfd_link_info *info;
3669 struct elf_link_hash_entry *h;
3670 Elf_Internal_Sym *sym;
3672 bfd *dynobj = elf_hash_table(info)->dynobj;
3674 if (h->plt.offset != MINUS_ONE)
3676 /* Fill in the .plt entry for this symbol. */
3677 asection *splt, *sgot, *srel;
3678 Elf_Internal_Rela outrel;
3679 bfd_vma got_addr, plt_addr;
3681 struct alpha_elf_got_entry *gotent;
3683 BFD_ASSERT (h->dynindx != -1);
3685 /* The first .got entry will be updated by the .plt with the
3686 address of the target function. */
3687 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3688 BFD_ASSERT (gotent && gotent->addend == 0);
3690 splt = bfd_get_section_by_name (dynobj, ".plt");
3691 BFD_ASSERT (splt != NULL);
3692 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3693 BFD_ASSERT (srel != NULL);
3694 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3695 BFD_ASSERT (sgot != NULL);
3697 got_addr = (sgot->output_section->vma
3698 + sgot->output_offset
3699 + gotent->got_offset);
3700 plt_addr = (splt->output_section->vma
3701 + splt->output_offset
3704 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3706 /* Fill in the entry in the procedure linkage table. */
3708 unsigned insn1, insn2, insn3;
3710 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3711 insn2 = PLT_ENTRY_WORD2;
3712 insn3 = PLT_ENTRY_WORD3;
3714 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3715 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3716 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3719 /* Fill in the entry in the .rela.plt section. */
3720 outrel.r_offset = got_addr;
3721 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3722 outrel.r_addend = 0;
3724 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3725 ((Elf64_External_Rela *)srel->contents
3728 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3730 /* Mark the symbol as undefined, rather than as defined in the
3731 .plt section. Leave the value alone. */
3732 sym->st_shndx = SHN_UNDEF;
3735 /* Fill in the entries in the .got. */
3736 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3738 /* Subsequent .got entries will continue to bounce through the .plt. */
3741 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3742 BFD_ASSERT (! info->shared || srel != NULL);
3744 gotent = gotent->next;
3747 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3748 BFD_ASSERT(sgot != NULL);
3749 BFD_ASSERT(gotent->addend == 0);
3751 bfd_put_64 (output_bfd, plt_addr,
3752 sgot->contents + gotent->got_offset);
3756 outrel.r_offset = (sgot->output_section->vma
3757 + sgot->output_offset
3758 + gotent->got_offset);
3759 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3760 outrel.r_addend = plt_addr;
3762 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3763 ((Elf64_External_Rela *)
3765 + srel->reloc_count++);
3766 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3767 <= srel->_cooked_size);
3770 gotent = gotent->next;
3772 while (gotent != NULL);
3775 else if (alpha_elf_dynamic_symbol_p (h, info))
3777 /* Fill in the dynamic relocations for this symbol's .got entries. */
3779 Elf_Internal_Rela outrel;
3780 struct alpha_elf_got_entry *gotent;
3782 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3783 BFD_ASSERT (srel != NULL);
3785 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3786 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3788 gotent = gotent->next)
3790 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3791 outrel.r_offset = (sgot->output_section->vma
3792 + sgot->output_offset
3793 + gotent->got_offset);
3794 outrel.r_addend = gotent->addend;
3796 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3797 ((Elf64_External_Rela *)srel->contents
3798 + srel->reloc_count++));
3799 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3800 <= srel->_cooked_size);
3804 /* Mark some specially defined symbols as absolute. */
3805 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3806 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3807 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3808 sym->st_shndx = SHN_ABS;
3813 /* Finish up the dynamic sections. */
3816 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3818 struct bfd_link_info *info;
3823 dynobj = elf_hash_table (info)->dynobj;
3824 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3826 if (elf_hash_table (info)->dynamic_sections_created)
3829 Elf64_External_Dyn *dyncon, *dynconend;
3831 splt = bfd_get_section_by_name (dynobj, ".plt");
3832 BFD_ASSERT (splt != NULL && sdyn != NULL);
3834 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3835 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3836 for (; dyncon < dynconend; dyncon++)
3838 Elf_Internal_Dyn dyn;
3842 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3857 /* My interpretation of the TIS v1.1 ELF document indicates
3858 that RELASZ should not include JMPREL. This is not what
3859 the rest of the BFD does. It is, however, what the
3860 glibc ld.so wants. Do this fixup here until we found
3861 out who is right. */
3862 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3866 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3871 s = bfd_get_section_by_name (output_bfd, name);
3872 dyn.d_un.d_ptr = (s ? s->vma : 0);
3876 s = bfd_get_section_by_name (output_bfd, name);
3878 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3882 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3885 /* Initialize the PLT0 entry */
3886 if (splt->_raw_size > 0)
3888 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3889 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3890 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3891 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3893 /* The next two words will be filled in by ld.so */
3894 bfd_put_64 (output_bfd, 0, splt->contents + 16);
3895 bfd_put_64 (output_bfd, 0, splt->contents + 24);
3897 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3905 /* We need to use a special link routine to handle the .reginfo and
3906 the .mdebug sections. We need to merge all instances of these
3907 sections together, not write them all out sequentially. */
3910 elf64_alpha_final_link (abfd, info)
3912 struct bfd_link_info *info;
3915 struct bfd_link_order *p;
3916 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
3917 struct ecoff_debug_info debug;
3918 const struct ecoff_debug_swap *swap
3919 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3920 HDRR *symhdr = &debug.symbolic_header;
3921 PTR mdebug_handle = NULL;
3926 (*info->callbacks->warning)
3927 (info, _("using multiple gp values"), (char *) NULL,
3928 output_bfd, (asection *) NULL, (bfd_vma) 0);
3932 /* Go through the sections and collect the .reginfo and .mdebug
3936 gptab_data_sec = NULL;
3937 gptab_bss_sec = NULL;
3938 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3940 #ifdef ERIC_neverdef
3941 if (strcmp (o->name, ".reginfo") == 0)
3943 memset (®info, 0, sizeof reginfo);
3945 /* We have found the .reginfo section in the output file.
3946 Look through all the link_orders comprising it and merge
3947 the information together. */
3948 for (p = o->link_order_head;
3949 p != (struct bfd_link_order *) NULL;
3952 asection *input_section;
3954 Elf64_External_RegInfo ext;
3957 if (p->type != bfd_indirect_link_order)
3959 if (p->type == bfd_fill_link_order)
3964 input_section = p->u.indirect.section;
3965 input_bfd = input_section->owner;
3967 /* The linker emulation code has probably clobbered the
3968 size to be zero bytes. */
3969 if (input_section->_raw_size == 0)
3970 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
3972 if (! bfd_get_section_contents (input_bfd, input_section,
3978 bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
3980 reginfo.ri_gprmask |= sub.ri_gprmask;
3981 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
3982 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
3983 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
3984 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
3986 /* ri_gp_value is set by the function
3987 alpha_elf_section_processing when the section is
3988 finally written out. */
3990 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3991 elf_link_input_bfd ignores this section. */
3992 input_section->flags &=~ SEC_HAS_CONTENTS;
3995 /* Force the section size to the value we want. */
3996 o->_raw_size = sizeof (Elf64_External_RegInfo);
3998 /* Skip this section later on (I don't think this currently
3999 matters, but someday it might). */
4000 o->link_order_head = (struct bfd_link_order *) NULL;
4006 if (strcmp (o->name, ".mdebug") == 0)
4008 struct extsym_info einfo;
4010 /* We have found the .mdebug section in the output file.
4011 Look through all the link_orders comprising it and merge
4012 the information together. */
4013 symhdr->magic = swap->sym_magic;
4014 /* FIXME: What should the version stamp be? */
4016 symhdr->ilineMax = 0;
4020 symhdr->isymMax = 0;
4021 symhdr->ioptMax = 0;
4022 symhdr->iauxMax = 0;
4024 symhdr->issExtMax = 0;
4027 symhdr->iextMax = 0;
4029 /* We accumulate the debugging information itself in the
4030 debug_info structure. */
4032 debug.external_dnr = NULL;
4033 debug.external_pdr = NULL;
4034 debug.external_sym = NULL;
4035 debug.external_opt = NULL;
4036 debug.external_aux = NULL;
4038 debug.ssext = debug.ssext_end = NULL;
4039 debug.external_fdr = NULL;
4040 debug.external_rfd = NULL;
4041 debug.external_ext = debug.external_ext_end = NULL;
4043 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4044 if (mdebug_handle == (PTR) NULL)
4053 static const char * const name[] =
4055 ".text", ".init", ".fini", ".data",
4056 ".rodata", ".sdata", ".sbss", ".bss"
4058 static const int sc[] = { scText, scInit, scFini, scData,
4059 scRData, scSData, scSBss, scBss };
4062 esym.cobol_main = 0;
4066 esym.asym.iss = issNil;
4067 esym.asym.st = stLocal;
4068 esym.asym.reserved = 0;
4069 esym.asym.index = indexNil;
4070 for (i = 0; i < 8; i++)
4072 esym.asym.sc = sc[i];
4073 s = bfd_get_section_by_name (abfd, name[i]);
4076 esym.asym.value = s->vma;
4077 last = s->vma + s->_raw_size;
4080 esym.asym.value = last;
4082 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4088 for (p = o->link_order_head;
4089 p != (struct bfd_link_order *) NULL;
4092 asection *input_section;
4094 const struct ecoff_debug_swap *input_swap;
4095 struct ecoff_debug_info input_debug;
4099 if (p->type != bfd_indirect_link_order)
4101 if (p->type == bfd_fill_link_order)
4106 input_section = p->u.indirect.section;
4107 input_bfd = input_section->owner;
4109 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4110 || (get_elf_backend_data (input_bfd)
4111 ->elf_backend_ecoff_debug_swap) == NULL)
4113 /* I don't know what a non ALPHA ELF bfd would be
4114 doing with a .mdebug section, but I don't really
4115 want to deal with it. */
4119 input_swap = (get_elf_backend_data (input_bfd)
4120 ->elf_backend_ecoff_debug_swap);
4122 BFD_ASSERT (p->size == input_section->_raw_size);
4124 /* The ECOFF linking code expects that we have already
4125 read in the debugging information and set up an
4126 ecoff_debug_info structure, so we do that now. */
4127 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4131 if (! (bfd_ecoff_debug_accumulate
4132 (mdebug_handle, abfd, &debug, swap, input_bfd,
4133 &input_debug, input_swap, info)))
4136 /* Loop through the external symbols. For each one with
4137 interesting information, try to find the symbol in
4138 the linker global hash table and save the information
4139 for the output external symbols. */
4140 eraw_src = input_debug.external_ext;
4141 eraw_end = (eraw_src
4142 + (input_debug.symbolic_header.iextMax
4143 * input_swap->external_ext_size));
4145 eraw_src < eraw_end;
4146 eraw_src += input_swap->external_ext_size)
4150 struct alpha_elf_link_hash_entry *h;
4152 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4153 if (ext.asym.sc == scNil
4154 || ext.asym.sc == scUndefined
4155 || ext.asym.sc == scSUndefined)
4158 name = input_debug.ssext + ext.asym.iss;
4159 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4160 name, false, false, true);
4161 if (h == NULL || h->esym.ifd != -2)
4167 < input_debug.symbolic_header.ifdMax);
4168 ext.ifd = input_debug.ifdmap[ext.ifd];
4174 /* Free up the information we just read. */
4175 free (input_debug.line);
4176 free (input_debug.external_dnr);
4177 free (input_debug.external_pdr);
4178 free (input_debug.external_sym);
4179 free (input_debug.external_opt);
4180 free (input_debug.external_aux);
4181 free (input_debug.ss);
4182 free (input_debug.ssext);
4183 free (input_debug.external_fdr);
4184 free (input_debug.external_rfd);
4185 free (input_debug.external_ext);
4187 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4188 elf_link_input_bfd ignores this section. */
4189 input_section->flags &=~ SEC_HAS_CONTENTS;
4192 #ifdef ERIC_neverdef
4195 /* Create .rtproc section. */
4196 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4197 if (rtproc_sec == NULL)
4199 flagword flags = (SEC_HAS_CONTENTS
4201 | SEC_LINKER_CREATED
4204 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4205 if (rtproc_sec == NULL
4206 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4207 || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4211 if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4212 info, rtproc_sec, &debug))
4217 /* Build the external symbol information. */
4220 einfo.debug = &debug;
4222 einfo.failed = false;
4223 elf_link_hash_traverse (elf_hash_table (info),
4224 elf64_alpha_output_extsym,
4229 /* Set the size of the .mdebug section. */
4230 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4232 /* Skip this section later on (I don't think this currently
4233 matters, but someday it might). */
4234 o->link_order_head = (struct bfd_link_order *) NULL;
4239 #ifdef ERIC_neverdef
4240 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4242 const char *subname;
4245 Elf64_External_gptab *ext_tab;
4248 /* The .gptab.sdata and .gptab.sbss sections hold
4249 information describing how the small data area would
4250 change depending upon the -G switch. These sections
4251 not used in executables files. */
4252 if (! info->relocateable)
4256 for (p = o->link_order_head;
4257 p != (struct bfd_link_order *) NULL;
4260 asection *input_section;
4262 if (p->type != bfd_indirect_link_order)
4264 if (p->type == bfd_fill_link_order)
4269 input_section = p->u.indirect.section;
4271 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4272 elf_link_input_bfd ignores this section. */
4273 input_section->flags &=~ SEC_HAS_CONTENTS;
4276 /* Skip this section later on (I don't think this
4277 currently matters, but someday it might). */
4278 o->link_order_head = (struct bfd_link_order *) NULL;
4280 /* Really remove the section. */
4281 for (secpp = &abfd->sections;
4283 secpp = &(*secpp)->next)
4285 *secpp = (*secpp)->next;
4286 --abfd->section_count;
4291 /* There is one gptab for initialized data, and one for
4292 uninitialized data. */
4293 if (strcmp (o->name, ".gptab.sdata") == 0)
4295 else if (strcmp (o->name, ".gptab.sbss") == 0)
4299 (*_bfd_error_handler)
4300 (_("%s: illegal section name `%s'"),
4301 bfd_get_filename (abfd), o->name);
4302 bfd_set_error (bfd_error_nonrepresentable_section);
4306 /* The linker script always combines .gptab.data and
4307 .gptab.sdata into .gptab.sdata, and likewise for
4308 .gptab.bss and .gptab.sbss. It is possible that there is
4309 no .sdata or .sbss section in the output file, in which
4310 case we must change the name of the output section. */
4311 subname = o->name + sizeof ".gptab" - 1;
4312 if (bfd_get_section_by_name (abfd, subname) == NULL)
4314 if (o == gptab_data_sec)
4315 o->name = ".gptab.data";
4317 o->name = ".gptab.bss";
4318 subname = o->name + sizeof ".gptab" - 1;
4319 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4322 /* Set up the first entry. */
4324 tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4327 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4328 tab[0].gt_header.gt_unused = 0;
4330 /* Combine the input sections. */
4331 for (p = o->link_order_head;
4332 p != (struct bfd_link_order *) NULL;
4335 asection *input_section;
4339 bfd_size_type gpentry;
4341 if (p->type != bfd_indirect_link_order)
4343 if (p->type == bfd_fill_link_order)
4348 input_section = p->u.indirect.section;
4349 input_bfd = input_section->owner;
4351 /* Combine the gptab entries for this input section one
4352 by one. We know that the input gptab entries are
4353 sorted by ascending -G value. */
4354 size = bfd_section_size (input_bfd, input_section);
4356 for (gpentry = sizeof (Elf64_External_gptab);
4358 gpentry += sizeof (Elf64_External_gptab))
4360 Elf64_External_gptab ext_gptab;
4361 Elf64_gptab int_gptab;
4367 if (! (bfd_get_section_contents
4368 (input_bfd, input_section, (PTR) &ext_gptab,
4369 gpentry, sizeof (Elf64_External_gptab))))
4375 bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4377 val = int_gptab.gt_entry.gt_g_value;
4378 add = int_gptab.gt_entry.gt_bytes - last;
4381 for (look = 1; look < c; look++)
4383 if (tab[look].gt_entry.gt_g_value >= val)
4384 tab[look].gt_entry.gt_bytes += add;
4386 if (tab[look].gt_entry.gt_g_value == val)
4392 Elf64_gptab *new_tab;
4395 /* We need a new table entry. */
4396 new_tab = ((Elf64_gptab *)
4397 bfd_realloc ((PTR) tab,
4398 (c + 1) * sizeof (Elf64_gptab)));
4399 if (new_tab == NULL)
4405 tab[c].gt_entry.gt_g_value = val;
4406 tab[c].gt_entry.gt_bytes = add;
4408 /* Merge in the size for the next smallest -G
4409 value, since that will be implied by this new
4412 for (look = 1; look < c; look++)
4414 if (tab[look].gt_entry.gt_g_value < val
4416 || (tab[look].gt_entry.gt_g_value
4417 > tab[max].gt_entry.gt_g_value)))
4421 tab[c].gt_entry.gt_bytes +=
4422 tab[max].gt_entry.gt_bytes;
4427 last = int_gptab.gt_entry.gt_bytes;
4430 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4431 elf_link_input_bfd ignores this section. */
4432 input_section->flags &=~ SEC_HAS_CONTENTS;
4435 /* The table must be sorted by -G value. */
4437 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4439 /* Swap out the table. */
4440 ext_tab = ((Elf64_External_gptab *)
4441 bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4442 if (ext_tab == NULL)
4448 for (i = 0; i < c; i++)
4449 bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4452 o->_raw_size = c * sizeof (Elf64_External_gptab);
4453 o->contents = (bfd_byte *) ext_tab;
4455 /* Skip this section later on (I don't think this currently
4456 matters, but someday it might). */
4457 o->link_order_head = (struct bfd_link_order *) NULL;
4463 /* Invoke the regular ELF backend linker to do all the work. */
4464 if (! bfd_elf64_bfd_final_link (abfd, info))
4467 /* Now write out the computed sections. */
4469 /* The .got subsections... */
4471 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4472 for (i = alpha_elf_hash_table(info)->got_list;
4474 i = alpha_elf_tdata(i)->got_link_next)
4478 /* elf_bfd_final_link already did everything in dynobj. */
4482 sgot = alpha_elf_tdata(i)->got;
4483 if (! bfd_set_section_contents (abfd, sgot->output_section,
4484 sgot->contents, sgot->output_offset,
4490 #ifdef ERIC_neverdef
4491 if (reginfo_sec != (asection *) NULL)
4493 Elf64_External_RegInfo ext;
4495 bfd_alpha_elf64_swap_reginfo_out (abfd, ®info, &ext);
4496 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4497 (file_ptr) 0, sizeof ext))
4502 if (mdebug_sec != (asection *) NULL)
4504 BFD_ASSERT (abfd->output_has_begun);
4505 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4507 mdebug_sec->filepos))
4510 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4513 if (gptab_data_sec != (asection *) NULL)
4515 if (! bfd_set_section_contents (abfd, gptab_data_sec,
4516 gptab_data_sec->contents,
4518 gptab_data_sec->_raw_size))
4522 if (gptab_bss_sec != (asection *) NULL)
4524 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4525 gptab_bss_sec->contents,
4527 gptab_bss_sec->_raw_size))
4534 static enum elf_reloc_type_class
4535 elf64_alpha_reloc_type_class (type)
4540 case R_ALPHA_RELATIVE:
4541 return reloc_class_relative;
4542 case R_ALPHA_JMP_SLOT:
4543 return reloc_class_plt;
4545 return reloc_class_copy;
4547 return reloc_class_normal;
4551 /* ECOFF swapping routines. These are used when dealing with the
4552 .mdebug section, which is in the ECOFF debugging format. Copied
4553 from elf32-mips.c. */
4554 static const struct ecoff_debug_swap
4555 elf64_alpha_ecoff_debug_swap =
4557 /* Symbol table magic number. */
4559 /* Alignment of debugging information. E.g., 4. */
4561 /* Sizes of external symbolic information. */
4562 sizeof (struct hdr_ext),
4563 sizeof (struct dnr_ext),
4564 sizeof (struct pdr_ext),
4565 sizeof (struct sym_ext),
4566 sizeof (struct opt_ext),
4567 sizeof (struct fdr_ext),
4568 sizeof (struct rfd_ext),
4569 sizeof (struct ext_ext),
4570 /* Functions to swap in external symbolic data. */
4579 _bfd_ecoff_swap_tir_in,
4580 _bfd_ecoff_swap_rndx_in,
4581 /* Functions to swap out external symbolic data. */
4590 _bfd_ecoff_swap_tir_out,
4591 _bfd_ecoff_swap_rndx_out,
4592 /* Function to read in symbolic data. */
4593 elf64_alpha_read_ecoff_info
4596 /* Use a non-standard hash bucket size of 8. */
4598 const struct elf_size_info alpha_elf_size_info =
4600 sizeof (Elf64_External_Ehdr),
4601 sizeof (Elf64_External_Phdr),
4602 sizeof (Elf64_External_Shdr),
4603 sizeof (Elf64_External_Rel),
4604 sizeof (Elf64_External_Rela),
4605 sizeof (Elf64_External_Sym),
4606 sizeof (Elf64_External_Dyn),
4607 sizeof (Elf_External_Note),
4611 ELFCLASS64, EV_CURRENT,
4612 bfd_elf64_write_out_phdrs,
4613 bfd_elf64_write_shdrs_and_ehdr,
4614 bfd_elf64_write_relocs,
4615 bfd_elf64_swap_symbol_out,
4616 bfd_elf64_slurp_reloc_table,
4617 bfd_elf64_slurp_symbol_table,
4618 bfd_elf64_swap_dyn_in,
4619 bfd_elf64_swap_dyn_out,
4626 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4627 #define TARGET_LITTLE_NAME "elf64-alpha"
4628 #define ELF_ARCH bfd_arch_alpha
4629 #define ELF_MACHINE_CODE EM_ALPHA
4630 #define ELF_MAXPAGESIZE 0x10000
4632 #define bfd_elf64_bfd_link_hash_table_create \
4633 elf64_alpha_bfd_link_hash_table_create
4635 #define bfd_elf64_bfd_reloc_type_lookup \
4636 elf64_alpha_bfd_reloc_type_lookup
4637 #define elf_info_to_howto \
4638 elf64_alpha_info_to_howto
4640 #define bfd_elf64_mkobject \
4641 elf64_alpha_mkobject
4642 #define elf_backend_object_p \
4643 elf64_alpha_object_p
4645 #define elf_backend_section_from_shdr \
4646 elf64_alpha_section_from_shdr
4647 #define elf_backend_fake_sections \
4648 elf64_alpha_fake_sections
4650 #define bfd_elf64_bfd_is_local_label_name \
4651 elf64_alpha_is_local_label_name
4652 #define bfd_elf64_find_nearest_line \
4653 elf64_alpha_find_nearest_line
4654 #define bfd_elf64_bfd_relax_section \
4655 elf64_alpha_relax_section
4657 #define elf_backend_add_symbol_hook \
4658 elf64_alpha_add_symbol_hook
4659 #define elf_backend_check_relocs \
4660 elf64_alpha_check_relocs
4661 #define elf_backend_create_dynamic_sections \
4662 elf64_alpha_create_dynamic_sections
4663 #define elf_backend_adjust_dynamic_symbol \
4664 elf64_alpha_adjust_dynamic_symbol
4665 #define elf_backend_always_size_sections \
4666 elf64_alpha_always_size_sections
4667 #define elf_backend_size_dynamic_sections \
4668 elf64_alpha_size_dynamic_sections
4669 #define elf_backend_relocate_section \
4670 elf64_alpha_relocate_section
4671 #define elf_backend_finish_dynamic_symbol \
4672 elf64_alpha_finish_dynamic_symbol
4673 #define elf_backend_finish_dynamic_sections \
4674 elf64_alpha_finish_dynamic_sections
4675 #define bfd_elf64_bfd_final_link \
4676 elf64_alpha_final_link
4677 #define elf_backend_reloc_type_class \
4678 elf64_alpha_reloc_type_class
4680 #define elf_backend_ecoff_debug_swap \
4681 &elf64_alpha_ecoff_debug_swap
4683 #define elf_backend_size_info \
4686 /* A few constants that determine how the .plt section is set up. */
4687 #define elf_backend_want_got_plt 0
4688 #define elf_backend_plt_readonly 0
4689 #define elf_backend_want_plt_sym 1
4690 #define elf_backend_got_header_size 0
4691 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4693 #include "elf64-target.h"