1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
52 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
54 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
66 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd *, bfd_reloc_code_real_type));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
77 static boolean elf64_alpha_section_flags
78 PARAMS((flagword *, Elf64_Internal_Shdr *));
79 static boolean elf64_alpha_fake_sections
80 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
81 static boolean elf64_alpha_create_got_section
82 PARAMS((bfd *, struct bfd_link_info *));
83 static boolean elf64_alpha_create_dynamic_sections
84 PARAMS((bfd *, struct bfd_link_info *));
86 static boolean elf64_alpha_read_ecoff_info
87 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
88 static boolean elf64_alpha_is_local_label_name
89 PARAMS((bfd *, const char *));
90 static boolean elf64_alpha_find_nearest_line
91 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
92 const char **, unsigned int *));
94 #if defined(__STDC__) || defined(ALMOST_STDC)
95 struct alpha_elf_link_hash_entry;
98 static boolean elf64_alpha_output_extsym
99 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
101 static boolean elf64_alpha_can_merge_gots
102 PARAMS((bfd *, bfd *));
103 static void elf64_alpha_merge_gots
104 PARAMS((bfd *, bfd *));
105 static boolean elf64_alpha_calc_got_offsets_for_symbol
106 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
107 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
108 static boolean elf64_alpha_size_got_sections
109 PARAMS ((bfd *, struct bfd_link_info *));
110 static boolean elf64_alpha_always_size_sections
111 PARAMS ((bfd *, struct bfd_link_info *));
112 static boolean elf64_alpha_calc_dynrel_sizes
113 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
114 static boolean elf64_alpha_add_symbol_hook
115 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
116 const char **, flagword *, asection **, bfd_vma *));
117 static boolean elf64_alpha_check_relocs
118 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
119 const Elf_Internal_Rela *));
120 static boolean elf64_alpha_adjust_dynamic_symbol
121 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
122 static boolean elf64_alpha_size_dynamic_sections
123 PARAMS((bfd *, struct bfd_link_info *));
124 static boolean elf64_alpha_relocate_section
125 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
126 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
127 static boolean elf64_alpha_finish_dynamic_symbol
128 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
129 Elf_Internal_Sym *));
130 static boolean elf64_alpha_finish_dynamic_sections
131 PARAMS((bfd *, struct bfd_link_info *));
132 static boolean elf64_alpha_final_link
133 PARAMS((bfd *, struct bfd_link_info *));
134 static boolean elf64_alpha_merge_ind_symbols
135 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
136 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
137 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
138 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
139 PARAMS ((const Elf_Internal_Rela *));
141 struct alpha_elf_link_hash_entry
143 struct elf_link_hash_entry root;
145 /* External symbol information. */
148 /* Cumulative flags for all the .got entries. */
151 /* Contexts (LITUSE) in which a literal was referenced. */
152 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
153 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
154 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
155 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
157 /* Used to implement multiple .got subsections. */
158 struct alpha_elf_got_entry
160 struct alpha_elf_got_entry *next;
162 /* which .got subsection? */
165 /* the addend in effect for this entry. */
168 /* the .got offset for this entry. */
173 /* Additional flags. */
174 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
175 #define ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED 0x20
180 /* used to count non-got, non-plt relocations for delayed sizing
181 of relocation sections. */
182 struct alpha_elf_reloc_entry
184 struct alpha_elf_reloc_entry *next;
186 /* which .reloc section? */
189 /* what kind of relocation? */
192 /* is this against read-only section? */
193 unsigned int reltext : 1;
195 /* how many did we find? */
200 /* Alpha ELF linker hash table. */
202 struct alpha_elf_link_hash_table
204 struct elf_link_hash_table root;
206 /* The head of a list of .got subsections linked through
207 alpha_elf_tdata(abfd)->got_link_next. */
211 /* Look up an entry in a Alpha ELF linker hash table. */
213 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
214 ((struct alpha_elf_link_hash_entry *) \
215 elf_link_hash_lookup (&(table)->root, (string), (create), \
218 /* Traverse a Alpha ELF linker hash table. */
220 #define alpha_elf_link_hash_traverse(table, func, info) \
221 (elf_link_hash_traverse \
223 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
226 /* Get the Alpha ELF linker hash table from a link_info structure. */
228 #define alpha_elf_hash_table(p) \
229 ((struct alpha_elf_link_hash_table *) ((p)->hash))
231 /* Get the object's symbols as our own entry type. */
233 #define alpha_elf_sym_hashes(abfd) \
234 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
236 /* Should we do dynamic things to this symbol? */
239 alpha_elf_dynamic_symbol_p (h, info)
240 struct elf_link_hash_entry *h;
241 struct bfd_link_info *info;
246 while (h->root.type == bfd_link_hash_indirect
247 || h->root.type == bfd_link_hash_warning)
248 h = (struct elf_link_hash_entry *) h->root.u.i.link;
250 if (h->dynindx == -1)
253 if (h->root.type == bfd_link_hash_undefweak
254 || h->root.type == bfd_link_hash_defweak)
257 switch (ELF_ST_VISIBILITY (h->other))
265 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
270 if ((info->shared && !info->symbolic)
271 || ((h->elf_link_hash_flags
272 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
273 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
279 /* Create an entry in a Alpha ELF linker hash table. */
281 static struct bfd_hash_entry *
282 elf64_alpha_link_hash_newfunc (entry, table, string)
283 struct bfd_hash_entry *entry;
284 struct bfd_hash_table *table;
287 struct alpha_elf_link_hash_entry *ret =
288 (struct alpha_elf_link_hash_entry *) entry;
290 /* Allocate the structure if it has not already been allocated by a
292 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
293 ret = ((struct alpha_elf_link_hash_entry *)
294 bfd_hash_allocate (table,
295 sizeof (struct alpha_elf_link_hash_entry)));
296 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
297 return (struct bfd_hash_entry *) ret;
299 /* Call the allocation method of the superclass. */
300 ret = ((struct alpha_elf_link_hash_entry *)
301 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
303 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
305 /* Set local fields. */
306 memset (&ret->esym, 0, sizeof (EXTR));
307 /* We use -2 as a marker to indicate that the information has
308 not been set. -1 means there is no associated ifd. */
311 ret->got_entries = NULL;
312 ret->reloc_entries = NULL;
315 return (struct bfd_hash_entry *) ret;
318 /* Create a Alpha ELF linker hash table. */
320 static struct bfd_link_hash_table *
321 elf64_alpha_bfd_link_hash_table_create (abfd)
324 struct alpha_elf_link_hash_table *ret;
325 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
327 ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
328 if (ret == (struct alpha_elf_link_hash_table *) NULL)
331 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
332 elf64_alpha_link_hash_newfunc))
334 bfd_release (abfd, ret);
338 return &ret->root.root;
341 /* We have some private fields hanging off of the elf_tdata structure. */
343 struct alpha_elf_obj_tdata
345 struct elf_obj_tdata root;
347 /* For every input file, these are the got entries for that object's
349 struct alpha_elf_got_entry ** local_got_entries;
351 /* For every input file, this is the object that owns the got that
352 this input file uses. */
355 /* For every got, this is a linked list through the objects using this got */
356 bfd *in_got_link_next;
358 /* For every got, this is a link to the next got subsegment. */
361 /* For every got, this is the section. */
364 /* For every got, this is it's total number of *entries*. */
365 int total_got_entries;
367 /* For every got, this is the sum of the number of *entries* required
368 to hold all of the member object's local got. */
369 int n_local_got_entries;
372 #define alpha_elf_tdata(abfd) \
373 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
376 elf64_alpha_mkobject (abfd)
379 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
380 abfd->tdata.any = bfd_zalloc (abfd, amt);
381 if (abfd->tdata.any == NULL)
387 elf64_alpha_object_p (abfd)
390 /* Allocate our special target data. */
391 struct alpha_elf_obj_tdata *new_tdata;
392 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
393 new_tdata = bfd_zalloc (abfd, amt);
394 if (new_tdata == NULL)
396 new_tdata->root = *abfd->tdata.elf_obj_data;
397 abfd->tdata.any = new_tdata;
399 /* Set the right machine number for an Alpha ELF file. */
400 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
403 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
404 from smaller values. Start with zero, widen, *then* decrement. */
405 #define MINUS_ONE (((bfd_vma)0) - 1)
407 #define SKIP_HOWTO(N) \
408 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
410 static reloc_howto_type elf64_alpha_howto_table[] =
412 HOWTO (R_ALPHA_NONE, /* type */
414 0, /* size (0 = byte, 1 = short, 2 = long) */
416 true, /* pc_relative */
418 complain_overflow_dont, /* complain_on_overflow */
419 elf64_alpha_reloc_nil, /* special_function */
421 false, /* partial_inplace */
424 true), /* pcrel_offset */
426 /* A 32 bit reference to a symbol. */
427 HOWTO (R_ALPHA_REFLONG, /* type */
429 2, /* size (0 = byte, 1 = short, 2 = long) */
431 false, /* pc_relative */
433 complain_overflow_bitfield, /* complain_on_overflow */
434 0, /* special_function */
435 "REFLONG", /* name */
436 false, /* partial_inplace */
437 0xffffffff, /* src_mask */
438 0xffffffff, /* dst_mask */
439 false), /* pcrel_offset */
441 /* A 64 bit reference to a symbol. */
442 HOWTO (R_ALPHA_REFQUAD, /* type */
444 4, /* size (0 = byte, 1 = short, 2 = long) */
446 false, /* pc_relative */
448 complain_overflow_bitfield, /* complain_on_overflow */
449 0, /* special_function */
450 "REFQUAD", /* name */
451 false, /* partial_inplace */
452 MINUS_ONE, /* src_mask */
453 MINUS_ONE, /* dst_mask */
454 false), /* pcrel_offset */
456 /* A 32 bit GP relative offset. This is just like REFLONG except
457 that when the value is used the value of the gp register will be
459 HOWTO (R_ALPHA_GPREL32, /* type */
461 2, /* size (0 = byte, 1 = short, 2 = long) */
463 false, /* pc_relative */
465 complain_overflow_bitfield, /* complain_on_overflow */
466 0, /* special_function */
467 "GPREL32", /* name */
468 false, /* partial_inplace */
469 0xffffffff, /* src_mask */
470 0xffffffff, /* dst_mask */
471 false), /* pcrel_offset */
473 /* Used for an instruction that refers to memory off the GP register. */
474 HOWTO (R_ALPHA_LITERAL, /* type */
476 1, /* size (0 = byte, 1 = short, 2 = long) */
478 false, /* pc_relative */
480 complain_overflow_signed, /* complain_on_overflow */
481 0, /* special_function */
482 "ELF_LITERAL", /* name */
483 false, /* partial_inplace */
484 0xffff, /* src_mask */
485 0xffff, /* dst_mask */
486 false), /* pcrel_offset */
488 /* This reloc only appears immediately following an ELF_LITERAL reloc.
489 It identifies a use of the literal. The symbol index is special:
490 1 means the literal address is in the base register of a memory
491 format instruction; 2 means the literal address is in the byte
492 offset register of a byte-manipulation instruction; 3 means the
493 literal address is in the target register of a jsr instruction.
494 This does not actually do any relocation. */
495 HOWTO (R_ALPHA_LITUSE, /* type */
497 1, /* size (0 = byte, 1 = short, 2 = long) */
499 false, /* pc_relative */
501 complain_overflow_dont, /* complain_on_overflow */
502 elf64_alpha_reloc_nil, /* special_function */
504 false, /* partial_inplace */
507 false), /* pcrel_offset */
509 /* Load the gp register. This is always used for a ldah instruction
510 which loads the upper 16 bits of the gp register. The symbol
511 index of the GPDISP instruction is an offset in bytes to the lda
512 instruction that loads the lower 16 bits. The value to use for
513 the relocation is the difference between the GP value and the
514 current location; the load will always be done against a register
515 holding the current address.
517 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
518 any offset is present in the instructions, it is an offset from
519 the register to the ldah instruction. This lets us avoid any
520 stupid hackery like inventing a gp value to do partial relocation
521 against. Also unlike ECOFF, we do the whole relocation off of
522 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
523 space consuming bit, that, since all the information was present
524 in the GPDISP_HI16 reloc. */
525 HOWTO (R_ALPHA_GPDISP, /* type */
527 2, /* size (0 = byte, 1 = short, 2 = long) */
529 false, /* pc_relative */
531 complain_overflow_dont, /* complain_on_overflow */
532 elf64_alpha_reloc_gpdisp, /* special_function */
534 false, /* partial_inplace */
535 0xffff, /* src_mask */
536 0xffff, /* dst_mask */
537 true), /* pcrel_offset */
539 /* A 21 bit branch. */
540 HOWTO (R_ALPHA_BRADDR, /* type */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
544 true, /* pc_relative */
546 complain_overflow_signed, /* complain_on_overflow */
547 0, /* special_function */
549 false, /* partial_inplace */
550 0x1fffff, /* src_mask */
551 0x1fffff, /* dst_mask */
552 true), /* pcrel_offset */
554 /* A hint for a jump to a register. */
555 HOWTO (R_ALPHA_HINT, /* type */
557 1, /* size (0 = byte, 1 = short, 2 = long) */
559 true, /* pc_relative */
561 complain_overflow_dont, /* complain_on_overflow */
562 0, /* special_function */
564 false, /* partial_inplace */
565 0x3fff, /* src_mask */
566 0x3fff, /* dst_mask */
567 true), /* pcrel_offset */
569 /* 16 bit PC relative offset. */
570 HOWTO (R_ALPHA_SREL16, /* type */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
574 true, /* pc_relative */
576 complain_overflow_signed, /* complain_on_overflow */
577 0, /* special_function */
579 false, /* partial_inplace */
580 0xffff, /* src_mask */
581 0xffff, /* dst_mask */
582 true), /* pcrel_offset */
584 /* 32 bit PC relative offset. */
585 HOWTO (R_ALPHA_SREL32, /* type */
587 2, /* size (0 = byte, 1 = short, 2 = long) */
589 true, /* pc_relative */
591 complain_overflow_signed, /* complain_on_overflow */
592 0, /* special_function */
594 false, /* partial_inplace */
595 0xffffffff, /* src_mask */
596 0xffffffff, /* dst_mask */
597 true), /* pcrel_offset */
599 /* A 64 bit PC relative offset. */
600 HOWTO (R_ALPHA_SREL64, /* type */
602 4, /* size (0 = byte, 1 = short, 2 = long) */
604 true, /* pc_relative */
606 complain_overflow_signed, /* complain_on_overflow */
607 0, /* special_function */
609 false, /* partial_inplace */
610 MINUS_ONE, /* src_mask */
611 MINUS_ONE, /* dst_mask */
612 true), /* pcrel_offset */
614 /* Skip 12 - 16; deprecated ECOFF relocs. */
621 /* The high 16 bits of the displacement from GP to the target. */
622 HOWTO (R_ALPHA_GPRELHIGH,
624 1, /* size (0 = byte, 1 = short, 2 = long) */
626 false, /* pc_relative */
628 complain_overflow_signed, /* complain_on_overflow */
629 0, /* special_function */
630 "GPRELHIGH", /* name */
631 false, /* partial_inplace */
632 0xffff, /* src_mask */
633 0xffff, /* dst_mask */
634 false), /* pcrel_offset */
636 /* The low 16 bits of the displacement from GP to the target. */
637 HOWTO (R_ALPHA_GPRELLOW,
639 1, /* size (0 = byte, 1 = short, 2 = long) */
641 false, /* pc_relative */
643 complain_overflow_dont, /* complain_on_overflow */
644 0, /* special_function */
645 "GPRELLOW", /* name */
646 false, /* partial_inplace */
647 0xffff, /* src_mask */
648 0xffff, /* dst_mask */
649 false), /* pcrel_offset */
651 /* A 16-bit displacement from the GP to the target. */
652 HOWTO (R_ALPHA_GPREL16,
654 1, /* size (0 = byte, 1 = short, 2 = long) */
656 false, /* pc_relative */
658 complain_overflow_signed, /* complain_on_overflow */
659 0, /* special_function */
660 "GPREL16", /* name */
661 false, /* partial_inplace */
662 0xffff, /* src_mask */
663 0xffff, /* dst_mask */
664 false), /* pcrel_offset */
666 /* Skip 20 - 23; deprecated ECOFF relocs. */
672 /* Misc ELF relocations. */
674 /* A dynamic relocation to copy the target into our .dynbss section. */
675 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
676 is present because every other ELF has one, but should not be used
677 because .dynbss is an ugly thing. */
684 complain_overflow_dont,
685 bfd_elf_generic_reloc,
692 /* A dynamic relocation for a .got entry. */
693 HOWTO (R_ALPHA_GLOB_DAT,
699 complain_overflow_dont,
700 bfd_elf_generic_reloc,
707 /* A dynamic relocation for a .plt entry. */
708 HOWTO (R_ALPHA_JMP_SLOT,
714 complain_overflow_dont,
715 bfd_elf_generic_reloc,
722 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
723 HOWTO (R_ALPHA_RELATIVE,
729 complain_overflow_dont,
730 bfd_elf_generic_reloc,
738 /* A relocation function which doesn't do anything. */
740 static bfd_reloc_status_type
741 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
742 bfd *abfd ATTRIBUTE_UNUSED;
744 asymbol *sym ATTRIBUTE_UNUSED;
745 PTR data ATTRIBUTE_UNUSED;
748 char **error_message ATTRIBUTE_UNUSED;
751 reloc->address += sec->output_offset;
755 /* A relocation function used for an unsupported reloc. */
757 static bfd_reloc_status_type
758 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
759 bfd *abfd ATTRIBUTE_UNUSED;
761 asymbol *sym ATTRIBUTE_UNUSED;
762 PTR data ATTRIBUTE_UNUSED;
765 char **error_message ATTRIBUTE_UNUSED;
768 reloc->address += sec->output_offset;
769 return bfd_reloc_notsupported;
772 /* Do the work of the GPDISP relocation. */
774 static bfd_reloc_status_type
775 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
781 bfd_reloc_status_type ret = bfd_reloc_ok;
783 unsigned long i_ldah, i_lda;
785 i_ldah = bfd_get_32 (abfd, p_ldah);
786 i_lda = bfd_get_32 (abfd, p_lda);
788 /* Complain if the instructions are not correct. */
789 if (((i_ldah >> 26) & 0x3f) != 0x09
790 || ((i_lda >> 26) & 0x3f) != 0x08)
791 ret = bfd_reloc_dangerous;
793 /* Extract the user-supplied offset, mirroring the sign extensions
794 that the instructions perform. */
795 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
796 addend = (addend ^ 0x80008000) - 0x80008000;
800 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
801 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
802 ret = bfd_reloc_overflow;
804 /* compensate for the sign extension again. */
805 i_ldah = ((i_ldah & 0xffff0000)
806 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
807 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
809 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
810 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
815 /* The special function for the GPDISP reloc. */
817 static bfd_reloc_status_type
818 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
821 arelent *reloc_entry;
822 asymbol *sym ATTRIBUTE_UNUSED;
824 asection *input_section;
828 bfd_reloc_status_type ret;
829 bfd_vma gp, relocation;
830 bfd_byte *p_ldah, *p_lda;
832 /* Don't do anything if we're not doing a final link. */
835 reloc_entry->address += input_section->output_offset;
839 if (reloc_entry->address > input_section->_cooked_size ||
840 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
841 return bfd_reloc_outofrange;
843 /* The gp used in the portion of the output object to which this
844 input object belongs is cached on the input bfd. */
845 gp = _bfd_get_gp_value (abfd);
847 relocation = (input_section->output_section->vma
848 + input_section->output_offset
849 + reloc_entry->address);
851 p_ldah = (bfd_byte *) data + reloc_entry->address;
852 p_lda = p_ldah + reloc_entry->addend;
854 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
856 /* Complain if the instructions are not correct. */
857 if (ret == bfd_reloc_dangerous)
858 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
863 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
867 bfd_reloc_code_real_type bfd_reloc_val;
871 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
873 {BFD_RELOC_NONE, R_ALPHA_NONE},
874 {BFD_RELOC_32, R_ALPHA_REFLONG},
875 {BFD_RELOC_64, R_ALPHA_REFQUAD},
876 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
877 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
878 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
879 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
880 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
881 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
882 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
883 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
884 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
885 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
886 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
887 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
888 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
891 /* Given a BFD reloc type, return a HOWTO structure. */
893 static reloc_howto_type *
894 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
895 bfd *abfd ATTRIBUTE_UNUSED;
896 bfd_reloc_code_real_type code;
898 const struct elf_reloc_map *i, *e;
899 i = e = elf64_alpha_reloc_map;
900 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
903 if (i->bfd_reloc_val == code)
904 return &elf64_alpha_howto_table[i->elf_reloc_val];
909 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
912 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
913 bfd *abfd ATTRIBUTE_UNUSED;
915 Elf64_Internal_Rela *dst;
919 r_type = ELF64_R_TYPE(dst->r_info);
920 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
921 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
924 /* These functions do relaxation for Alpha ELF.
926 Currently I'm only handling what I can do with existing compiler
927 and assembler support, which means no instructions are removed,
928 though some may be nopped. At this time GCC does not emit enough
929 information to do all of the relaxing that is possible. It will
930 take some not small amount of work for that to happen.
932 There are a couple of interesting papers that I once read on this
933 subject, that I cannot find references to at the moment, that
934 related to Alpha in particular. They are by David Wall, then of
939 #define INSN_JSR 0x68004000
940 #define INSN_JSR_MASK 0xfc00c000
944 #define INSN_UNOP 0x2fe00000
946 struct alpha_relax_info
951 Elf_Internal_Rela *relocs, *relend;
952 struct bfd_link_info *link_info;
953 boolean changed_contents;
954 boolean changed_relocs;
958 struct alpha_elf_link_hash_entry *h;
959 struct alpha_elf_got_entry *gotent;
963 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
964 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
965 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
967 static boolean elf64_alpha_relax_without_lituse
968 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
969 Elf_Internal_Rela *irel));
971 static bfd_vma elf64_alpha_relax_opt_call
972 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
974 static boolean elf64_alpha_relax_section
975 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
978 static Elf_Internal_Rela *
979 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
980 Elf_Internal_Rela *rel, *relend;
986 if (rel->r_offset == offset
987 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
994 static Elf_Internal_Rela *
995 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
996 struct alpha_relax_info *info;
998 Elf_Internal_Rela *irel, *irelend;
1000 Elf_Internal_Rela *urel;
1001 int flags, count, i;
1002 bfd_signed_vma disp;
1005 boolean lit_reused = false;
1006 boolean all_optimized = true;
1007 unsigned int lit_insn;
1009 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1010 if (lit_insn >> 26 != OP_LDQ)
1012 ((*_bfd_error_handler)
1013 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1014 bfd_archive_filename (info->abfd), info->sec->name,
1015 (unsigned long) irel->r_offset));
1019 /* Summarize how this particular LITERAL is used. */
1020 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1022 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1024 if (urel->r_addend <= 3)
1025 flags |= 1 << urel->r_addend;
1028 /* A little preparation for the loop... */
1029 disp = symval - info->gp;
1031 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1035 bfd_signed_vma xdisp;
1037 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1039 switch (urel->r_addend)
1041 default: /* 0 = ADDRESS FORMAT */
1042 /* This type is really just a placeholder to note that all
1043 uses cannot be optimized, but to still allow some. */
1044 all_optimized = false;
1047 case 1: /* MEM FORMAT */
1048 /* We can always optimize 16-bit displacements. */
1050 /* Extract the displacement from the instruction, sign-extending
1051 it if necessary, then test whether it is within 16 or 32 bits
1052 displacement from GP. */
1053 insn_disp = insn & 0x0000ffff;
1054 if (insn_disp & 0x00008000)
1055 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1057 xdisp = disp + insn_disp;
1058 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1059 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1063 /* Take the op code and dest from this insn, take the base
1064 register from the literal insn. Leave the offset alone. */
1065 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1066 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1068 urel->r_addend = irel->r_addend;
1069 info->changed_relocs = true;
1071 bfd_put_32 (info->abfd, (bfd_vma) insn,
1072 info->contents + urel->r_offset);
1073 info->changed_contents = true;
1076 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1077 else if (fits32 && !(flags & ~6))
1079 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1081 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1083 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1084 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1085 info->contents + irel->r_offset);
1087 info->changed_contents = true;
1089 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1091 urel->r_addend = irel->r_addend;
1092 info->changed_relocs = true;
1095 all_optimized = false;
1098 case 2: /* BYTE OFFSET FORMAT */
1099 /* We can always optimize byte instructions. */
1101 /* FIXME: sanity check the insn for byte op. Check that the
1102 literal dest reg is indeed Rb in the byte insn. */
1104 insn &= ~ (unsigned) 0x001ff000;
1105 insn |= ((symval & 7) << 13) | 0x1000;
1107 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1109 info->changed_relocs = true;
1111 bfd_put_32 (info->abfd, (bfd_vma) insn,
1112 info->contents + urel->r_offset);
1113 info->changed_contents = true;
1116 case 3: /* CALL FORMAT */
1118 /* If not zero, place to jump without needing pv. */
1119 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1120 bfd_vma org = (info->sec->output_section->vma
1121 + info->sec->output_offset
1122 + urel->r_offset + 4);
1123 bfd_signed_vma odisp;
1125 odisp = (optdest ? optdest : symval) - org;
1126 if (odisp >= -0x400000 && odisp < 0x400000)
1128 Elf_Internal_Rela *xrel;
1130 /* Preserve branch prediction call stack when possible. */
1131 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1132 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1134 insn = (OP_BR << 26) | (insn & 0x03e00000);
1136 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1138 urel->r_addend = irel->r_addend;
1141 urel->r_addend += optdest - symval;
1143 all_optimized = false;
1145 bfd_put_32 (info->abfd, (bfd_vma) insn,
1146 info->contents + urel->r_offset);
1148 /* Kill any HINT reloc that might exist for this insn. */
1149 xrel = (elf64_alpha_find_reloc_at_ofs
1150 (info->relocs, info->relend, urel->r_offset,
1153 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1155 info->changed_contents = true;
1156 info->changed_relocs = true;
1159 all_optimized = false;
1161 /* Even if the target is not in range for a direct branch,
1162 if we share a GP, we can eliminate the gp reload. */
1165 Elf_Internal_Rela *gpdisp
1166 = (elf64_alpha_find_reloc_at_ofs
1167 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1170 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1171 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1172 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1173 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1175 /* Verify that the instruction is "ldah $29,0($26)".
1176 Consider a function that ends in a noreturn call,
1177 and that the next function begins with an ldgp,
1178 and that by accident there is no padding between.
1179 In that case the insn would use $27 as the base. */
1180 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1182 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1183 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1185 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1186 info->changed_contents = true;
1187 info->changed_relocs = true;
1196 /* If all cases were optimized, we can reduce the use count on this
1197 got entry by one, possibly eliminating it. */
1200 info->gotent->use_count -= 1;
1201 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1203 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1205 /* If the literal instruction is no longer needed (it may have been
1206 reused. We can eliminate it.
1207 ??? For now, I don't want to deal with compacting the section,
1208 so just nop it out. */
1211 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1212 info->changed_relocs = true;
1214 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1215 info->contents + irel->r_offset);
1216 info->changed_contents = true;
1220 return irel + count;
1224 elf64_alpha_relax_opt_call (info, symval)
1225 struct alpha_relax_info *info;
1228 /* If the function has the same gp, and we can identify that the
1229 function does not use its function pointer, we can eliminate the
1232 /* If the symbol is marked NOPV, we are being told the function never
1233 needs its procedure value. */
1234 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1237 /* If the symbol is marked STD_GP, we are being told the function does
1238 a normal ldgp in the first two words. */
1239 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1242 /* Otherwise, we may be able to identify a GP load in the first two
1243 words, which we can then skip. */
1246 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1249 /* Load the relocations from the section that the target symbol is in. */
1250 if (info->sec == info->tsec)
1252 tsec_relocs = info->relocs;
1253 tsec_relend = info->relend;
1258 tsec_relocs = (_bfd_elf64_link_read_relocs
1259 (info->abfd, info->tsec, (PTR) NULL,
1260 (Elf_Internal_Rela *) NULL,
1261 info->link_info->keep_memory));
1262 if (tsec_relocs == NULL)
1264 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1265 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1268 /* Recover the symbol's offset within the section. */
1269 ofs = (symval - info->tsec->output_section->vma
1270 - info->tsec->output_offset);
1272 /* Look for a GPDISP reloc. */
1273 gpdisp = (elf64_alpha_find_reloc_at_ofs
1274 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1276 if (!gpdisp || gpdisp->r_addend != 4)
1286 /* We've now determined that we can skip an initial gp load. Verify
1287 that the call and the target use the same gp. */
1288 if (info->link_info->hash->creator != info->tsec->owner->xvec
1289 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1296 elf64_alpha_relax_without_lituse (info, symval, irel)
1297 struct alpha_relax_info *info;
1299 Elf_Internal_Rela *irel;
1302 bfd_signed_vma disp;
1304 /* Get the instruction. */
1305 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1307 if (insn >> 26 != OP_LDQ)
1309 ((*_bfd_error_handler)
1310 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1311 bfd_archive_filename (info->abfd), info->sec->name,
1312 (unsigned long) irel->r_offset));
1316 /* So we aren't told much. Do what we can with the address load and
1317 fake the rest. All of the optimizations here require that the
1318 offset from the GP fit in 16 bits. */
1320 disp = symval - info->gp;
1321 if (disp < -0x8000 || disp >= 0x8000)
1324 /* On the LITERAL instruction itself, consider exchanging
1325 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1327 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1328 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1329 info->changed_contents = true;
1331 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1332 info->changed_relocs = true;
1334 /* Reduce the use count on this got entry by one, possibly
1336 info->gotent->use_count -= 1;
1337 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1339 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1341 /* ??? Search forward through this basic block looking for insns
1342 that use the target register. Stop after an insn modifying the
1343 register is seen, or after a branch or call.
1345 Any such memory load insn may be substituted by a load directly
1346 off the GP. This allows the memory load insn to be issued before
1347 the calculated GP register would otherwise be ready.
1349 Any such jsr insn can be replaced by a bsr if it is in range.
1351 This would mean that we'd have to _add_ relocations, the pain of
1352 which gives one pause. */
1358 elf64_alpha_relax_section (abfd, sec, link_info, again)
1361 struct bfd_link_info *link_info;
1364 Elf_Internal_Shdr *symtab_hdr;
1365 Elf_Internal_Rela *internal_relocs;
1366 Elf_Internal_Rela *free_relocs = NULL;
1367 Elf_Internal_Rela *irel, *irelend;
1368 bfd_byte *free_contents = NULL;
1369 Elf64_External_Sym *extsyms = NULL;
1370 Elf64_External_Sym *free_extsyms = NULL;
1371 struct alpha_elf_got_entry **local_got_entries;
1372 struct alpha_relax_info info;
1374 /* We are not currently changing any sizes, so only one pass. */
1377 if (link_info->relocateable
1378 || (sec->flags & SEC_RELOC) == 0
1379 || sec->reloc_count == 0)
1382 /* If this is the first time we have been called for this section,
1383 initialize the cooked size. */
1384 if (sec->_cooked_size == 0)
1385 sec->_cooked_size = sec->_raw_size;
1387 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1388 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1390 /* Load the relocations for this section. */
1391 internal_relocs = (_bfd_elf64_link_read_relocs
1392 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1393 link_info->keep_memory));
1394 if (internal_relocs == NULL)
1396 if (! link_info->keep_memory)
1397 free_relocs = internal_relocs;
1399 memset(&info, 0, sizeof (info));
1402 info.link_info = link_info;
1403 info.relocs = internal_relocs;
1404 info.relend = irelend = internal_relocs + sec->reloc_count;
1406 /* Find the GP for this object. */
1407 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1410 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1411 info.gp = _bfd_get_gp_value (info.gotobj);
1414 info.gp = (sgot->output_section->vma
1415 + sgot->output_offset
1417 _bfd_set_gp_value (info.gotobj, info.gp);
1421 for (irel = internal_relocs; irel < irelend; irel++)
1424 Elf_Internal_Sym isym;
1425 struct alpha_elf_got_entry *gotent;
1427 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1430 /* Get the section contents. */
1431 if (info.contents == NULL)
1433 if (elf_section_data (sec)->this_hdr.contents != NULL)
1434 info.contents = elf_section_data (sec)->this_hdr.contents;
1437 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1438 if (info.contents == NULL)
1440 free_contents = info.contents;
1442 if (! bfd_get_section_contents (abfd, sec, info.contents,
1443 (file_ptr) 0, sec->_raw_size))
1448 /* Read this BFD's symbols if we haven't done so already. */
1449 if (extsyms == NULL)
1451 if (symtab_hdr->contents != NULL)
1452 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1455 extsyms = (Elf64_External_Sym *) bfd_malloc (symtab_hdr->sh_size);
1456 if (extsyms == NULL)
1458 free_extsyms = extsyms;
1459 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1460 || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
1461 != symtab_hdr->sh_size))
1466 /* Get the value of the symbol referred to by the reloc. */
1467 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1469 /* A local symbol. */
1470 bfd_elf64_swap_symbol_in (abfd,
1471 extsyms + ELF64_R_SYM (irel->r_info),
1473 if (isym.st_shndx == SHN_UNDEF)
1474 info.tsec = bfd_und_section_ptr;
1475 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1476 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1477 else if (isym.st_shndx == SHN_ABS)
1478 info.tsec = bfd_abs_section_ptr;
1479 else if (isym.st_shndx == SHN_COMMON)
1480 info.tsec = bfd_com_section_ptr;
1482 continue; /* who knows. */
1485 info.other = isym.st_other;
1486 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1487 symval = isym.st_value;
1492 struct alpha_elf_link_hash_entry *h;
1494 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1495 h = alpha_elf_sym_hashes (abfd)[indx];
1496 BFD_ASSERT (h != NULL);
1498 while (h->root.root.type == bfd_link_hash_indirect
1499 || h->root.root.type == bfd_link_hash_warning)
1500 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1502 /* We can't do anthing with undefined or dynamic symbols. */
1503 if (h->root.root.type == bfd_link_hash_undefined
1504 || h->root.root.type == bfd_link_hash_undefweak
1505 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1509 info.tsec = h->root.root.u.def.section;
1510 info.other = h->root.other;
1511 gotent = h->got_entries;
1512 symval = h->root.root.u.def.value;
1515 /* Search for the got entry to be used by this relocation. */
1516 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1517 gotent = gotent->next;
1518 info.gotent = gotent;
1520 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1521 symval += irel->r_addend;
1523 BFD_ASSERT(info.gotent != NULL);
1525 /* If there exist LITUSE relocations immediately following, this
1526 opens up all sorts of interesting optimizations, because we
1527 now know every location that this address load is used. */
1529 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1531 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1537 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1542 if (!elf64_alpha_size_got_sections (abfd, link_info))
1545 if (info.changed_relocs)
1547 elf_section_data (sec)->relocs = internal_relocs;
1549 else if (free_relocs != NULL)
1554 if (info.changed_contents)
1556 elf_section_data (sec)->this_hdr.contents = info.contents;
1558 else if (free_contents != NULL)
1560 if (! link_info->keep_memory)
1561 free (free_contents);
1564 /* Cache the section contents for elf_link_input_bfd. */
1565 elf_section_data (sec)->this_hdr.contents = info.contents;
1569 if (free_extsyms != NULL)
1571 if (! link_info->keep_memory)
1572 free (free_extsyms);
1575 /* Cache the symbols for elf_link_input_bfd. */
1576 symtab_hdr->contents = (unsigned char *) extsyms;
1580 *again = info.changed_contents || info.changed_relocs;
1585 if (free_relocs != NULL)
1587 if (free_contents != NULL)
1588 free (free_contents);
1589 if (free_extsyms != NULL)
1590 free (free_extsyms);
1595 #define PLT_HEADER_SIZE 32
1596 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1597 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1598 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1599 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
1601 #define PLT_ENTRY_SIZE 12
1602 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1603 #define PLT_ENTRY_WORD2 0
1604 #define PLT_ENTRY_WORD3 0
1606 #define MAX_GOT_ENTRIES (64*1024 / 8)
1608 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1610 /* Handle an Alpha specific section when reading an object file. This
1611 is called when elfcode.h finds a section with an unknown type.
1612 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1616 elf64_alpha_section_from_shdr (abfd, hdr, name)
1618 Elf64_Internal_Shdr *hdr;
1623 /* There ought to be a place to keep ELF backend specific flags, but
1624 at the moment there isn't one. We just keep track of the
1625 sections by their name, instead. Fortunately, the ABI gives
1626 suggested names for all the MIPS specific sections, so we will
1627 probably get away with this. */
1628 switch (hdr->sh_type)
1630 case SHT_ALPHA_DEBUG:
1631 if (strcmp (name, ".mdebug") != 0)
1638 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1640 newsect = hdr->bfd_section;
1642 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1644 if (! bfd_set_section_flags (abfd, newsect,
1645 (bfd_get_section_flags (abfd, newsect)
1653 /* Convert Alpha specific section flags to bfd internal section flags. */
1656 elf64_alpha_section_flags (flags, hdr)
1658 Elf64_Internal_Shdr *hdr;
1660 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1661 *flags |= SEC_SMALL_DATA;
1666 /* Set the correct type for an Alpha ELF section. We do this by the
1667 section name, which is a hack, but ought to work. */
1670 elf64_alpha_fake_sections (abfd, hdr, sec)
1672 Elf64_Internal_Shdr *hdr;
1675 register const char *name;
1677 name = bfd_get_section_name (abfd, sec);
1679 if (strcmp (name, ".mdebug") == 0)
1681 hdr->sh_type = SHT_ALPHA_DEBUG;
1682 /* In a shared object on Irix 5.3, the .mdebug section has an
1683 entsize of 0. FIXME: Does this matter? */
1684 if ((abfd->flags & DYNAMIC) != 0 )
1685 hdr->sh_entsize = 0;
1687 hdr->sh_entsize = 1;
1689 else if ((sec->flags & SEC_SMALL_DATA)
1690 || strcmp (name, ".sdata") == 0
1691 || strcmp (name, ".sbss") == 0
1692 || strcmp (name, ".lit4") == 0
1693 || strcmp (name, ".lit8") == 0)
1694 hdr->sh_flags |= SHF_ALPHA_GPREL;
1699 /* Hook called by the linker routine which adds symbols from an object
1700 file. We use it to put .comm items in .sbss, and not .bss. */
1703 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1705 struct bfd_link_info *info;
1706 const Elf_Internal_Sym *sym;
1707 const char **namep ATTRIBUTE_UNUSED;
1708 flagword *flagsp ATTRIBUTE_UNUSED;
1712 if (sym->st_shndx == SHN_COMMON
1713 && !info->relocateable
1714 && sym->st_size <= elf_gp_size (abfd))
1716 /* Common symbols less than or equal to -G nn bytes are
1717 automatically put into .sbss. */
1719 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1723 scomm = bfd_make_section (abfd, ".scommon");
1725 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1727 | SEC_LINKER_CREATED)))
1732 *valp = sym->st_size;
1738 /* Create the .got section. */
1741 elf64_alpha_create_got_section(abfd, info)
1743 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1747 if (bfd_get_section_by_name (abfd, ".got"))
1750 s = bfd_make_section (abfd, ".got");
1752 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1755 | SEC_LINKER_CREATED))
1756 || !bfd_set_section_alignment (abfd, s, 3))
1759 alpha_elf_tdata (abfd)->got = s;
1764 /* Create all the dynamic sections. */
1767 elf64_alpha_create_dynamic_sections (abfd, info)
1769 struct bfd_link_info *info;
1772 struct elf_link_hash_entry *h;
1774 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1776 s = bfd_make_section (abfd, ".plt");
1778 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1781 | SEC_LINKER_CREATED
1783 || ! bfd_set_section_alignment (abfd, s, 3))
1786 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1789 if (! (_bfd_generic_link_add_one_symbol
1790 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1791 (bfd_vma) 0, (const char *) NULL, false,
1792 get_elf_backend_data (abfd)->collect,
1793 (struct bfd_link_hash_entry **) &h)))
1795 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1796 h->type = STT_OBJECT;
1799 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1802 s = bfd_make_section (abfd, ".rela.plt");
1804 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1807 | SEC_LINKER_CREATED
1809 || ! bfd_set_section_alignment (abfd, s, 3))
1812 /* We may or may not have created a .got section for this object, but
1813 we definitely havn't done the rest of the work. */
1815 if (!elf64_alpha_create_got_section (abfd, info))
1818 s = bfd_make_section(abfd, ".rela.got");
1820 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1823 | SEC_LINKER_CREATED
1825 || !bfd_set_section_alignment (abfd, s, 3))
1828 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1829 dynobj's .got section. We don't do this in the linker script
1830 because we don't want to define the symbol if we are not creating
1831 a global offset table. */
1833 if (!(_bfd_generic_link_add_one_symbol
1834 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1835 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1836 false, get_elf_backend_data (abfd)->collect,
1837 (struct bfd_link_hash_entry **) &h)))
1839 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1840 h->type = STT_OBJECT;
1843 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1846 elf_hash_table (info)->hgot = h;
1851 /* Read ECOFF debugging information from a .mdebug section into a
1852 ecoff_debug_info structure. */
1855 elf64_alpha_read_ecoff_info (abfd, section, debug)
1858 struct ecoff_debug_info *debug;
1861 const struct ecoff_debug_swap *swap;
1862 char *ext_hdr = NULL;
1864 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1865 memset (debug, 0, sizeof (*debug));
1867 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1868 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1871 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1872 swap->external_hdr_size)
1876 symhdr = &debug->symbolic_header;
1877 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1879 /* The symbolic header contains absolute file offsets and sizes to
1881 #define READ(ptr, offset, count, size, type) \
1882 if (symhdr->count == 0) \
1883 debug->ptr = NULL; \
1886 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1887 debug->ptr = (type) bfd_malloc (amt); \
1888 if (debug->ptr == NULL) \
1889 goto error_return; \
1890 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1891 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1892 goto error_return; \
1895 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1896 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1897 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1898 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1899 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1900 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1902 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1903 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1904 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1905 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1906 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1910 debug->adjust = NULL;
1915 if (ext_hdr != NULL)
1917 if (debug->line != NULL)
1919 if (debug->external_dnr != NULL)
1920 free (debug->external_dnr);
1921 if (debug->external_pdr != NULL)
1922 free (debug->external_pdr);
1923 if (debug->external_sym != NULL)
1924 free (debug->external_sym);
1925 if (debug->external_opt != NULL)
1926 free (debug->external_opt);
1927 if (debug->external_aux != NULL)
1928 free (debug->external_aux);
1929 if (debug->ss != NULL)
1931 if (debug->ssext != NULL)
1932 free (debug->ssext);
1933 if (debug->external_fdr != NULL)
1934 free (debug->external_fdr);
1935 if (debug->external_rfd != NULL)
1936 free (debug->external_rfd);
1937 if (debug->external_ext != NULL)
1938 free (debug->external_ext);
1942 /* Alpha ELF local labels start with '$'. */
1945 elf64_alpha_is_local_label_name (abfd, name)
1946 bfd *abfd ATTRIBUTE_UNUSED;
1949 return name[0] == '$';
1952 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1953 routine in order to handle the ECOFF debugging information. We
1954 still call this mips_elf_find_line because of the slot
1955 find_line_info in elf_obj_tdata is declared that way. */
1957 struct mips_elf_find_line
1959 struct ecoff_debug_info d;
1960 struct ecoff_find_line i;
1964 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
1965 functionname_ptr, line_ptr)
1970 const char **filename_ptr;
1971 const char **functionname_ptr;
1972 unsigned int *line_ptr;
1976 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1977 filename_ptr, functionname_ptr,
1979 &elf_tdata (abfd)->dwarf2_find_line_info))
1982 msec = bfd_get_section_by_name (abfd, ".mdebug");
1986 struct mips_elf_find_line *fi;
1987 const struct ecoff_debug_swap * const swap =
1988 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1990 /* If we are called during a link, alpha_elf_final_link may have
1991 cleared the SEC_HAS_CONTENTS field. We force it back on here
1992 if appropriate (which it normally will be). */
1993 origflags = msec->flags;
1994 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1995 msec->flags |= SEC_HAS_CONTENTS;
1997 fi = elf_tdata (abfd)->find_line_info;
2000 bfd_size_type external_fdr_size;
2003 struct fdr *fdr_ptr;
2004 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2006 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2009 msec->flags = origflags;
2013 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2015 msec->flags = origflags;
2019 /* Swap in the FDR information. */
2020 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2021 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2022 if (fi->d.fdr == NULL)
2024 msec->flags = origflags;
2027 external_fdr_size = swap->external_fdr_size;
2028 fdr_ptr = fi->d.fdr;
2029 fraw_src = (char *) fi->d.external_fdr;
2030 fraw_end = (fraw_src
2031 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2032 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2033 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2035 elf_tdata (abfd)->find_line_info = fi;
2037 /* Note that we don't bother to ever free this information.
2038 find_nearest_line is either called all the time, as in
2039 objdump -l, so the information should be saved, or it is
2040 rarely called, as in ld error messages, so the memory
2041 wasted is unimportant. Still, it would probably be a
2042 good idea for free_cached_info to throw it away. */
2045 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2046 &fi->i, filename_ptr, functionname_ptr,
2049 msec->flags = origflags;
2053 msec->flags = origflags;
2056 /* Fall back on the generic ELF find_nearest_line routine. */
2058 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2059 filename_ptr, functionname_ptr,
2063 /* Structure used to pass information to alpha_elf_output_extsym. */
2068 struct bfd_link_info *info;
2069 struct ecoff_debug_info *debug;
2070 const struct ecoff_debug_swap *swap;
2075 elf64_alpha_output_extsym (h, data)
2076 struct alpha_elf_link_hash_entry *h;
2079 struct extsym_info *einfo = (struct extsym_info *) data;
2081 asection *sec, *output_section;
2083 if (h->root.indx == -2)
2085 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2086 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2087 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2088 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2090 else if (einfo->info->strip == strip_all
2091 || (einfo->info->strip == strip_some
2092 && bfd_hash_lookup (einfo->info->keep_hash,
2093 h->root.root.root.string,
2094 false, false) == NULL))
2102 if (h->esym.ifd == -2)
2105 h->esym.cobol_main = 0;
2106 h->esym.weakext = 0;
2107 h->esym.reserved = 0;
2108 h->esym.ifd = ifdNil;
2109 h->esym.asym.value = 0;
2110 h->esym.asym.st = stGlobal;
2112 if (h->root.root.type != bfd_link_hash_defined
2113 && h->root.root.type != bfd_link_hash_defweak)
2114 h->esym.asym.sc = scAbs;
2119 sec = h->root.root.u.def.section;
2120 output_section = sec->output_section;
2122 /* When making a shared library and symbol h is the one from
2123 the another shared library, OUTPUT_SECTION may be null. */
2124 if (output_section == NULL)
2125 h->esym.asym.sc = scUndefined;
2128 name = bfd_section_name (output_section->owner, output_section);
2130 if (strcmp (name, ".text") == 0)
2131 h->esym.asym.sc = scText;
2132 else if (strcmp (name, ".data") == 0)
2133 h->esym.asym.sc = scData;
2134 else if (strcmp (name, ".sdata") == 0)
2135 h->esym.asym.sc = scSData;
2136 else if (strcmp (name, ".rodata") == 0
2137 || strcmp (name, ".rdata") == 0)
2138 h->esym.asym.sc = scRData;
2139 else if (strcmp (name, ".bss") == 0)
2140 h->esym.asym.sc = scBss;
2141 else if (strcmp (name, ".sbss") == 0)
2142 h->esym.asym.sc = scSBss;
2143 else if (strcmp (name, ".init") == 0)
2144 h->esym.asym.sc = scInit;
2145 else if (strcmp (name, ".fini") == 0)
2146 h->esym.asym.sc = scFini;
2148 h->esym.asym.sc = scAbs;
2152 h->esym.asym.reserved = 0;
2153 h->esym.asym.index = indexNil;
2156 if (h->root.root.type == bfd_link_hash_common)
2157 h->esym.asym.value = h->root.root.u.c.size;
2158 else if (h->root.root.type == bfd_link_hash_defined
2159 || h->root.root.type == bfd_link_hash_defweak)
2161 if (h->esym.asym.sc == scCommon)
2162 h->esym.asym.sc = scBss;
2163 else if (h->esym.asym.sc == scSCommon)
2164 h->esym.asym.sc = scSBss;
2166 sec = h->root.root.u.def.section;
2167 output_section = sec->output_section;
2168 if (output_section != NULL)
2169 h->esym.asym.value = (h->root.root.u.def.value
2170 + sec->output_offset
2171 + output_section->vma);
2173 h->esym.asym.value = 0;
2175 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2177 /* Set type and value for a symbol with a function stub. */
2178 h->esym.asym.st = stProc;
2179 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2181 h->esym.asym.value = 0;
2184 output_section = sec->output_section;
2185 if (output_section != NULL)
2186 h->esym.asym.value = (h->root.plt.offset
2187 + sec->output_offset
2188 + output_section->vma);
2190 h->esym.asym.value = 0;
2194 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2195 h->root.root.root.string,
2198 einfo->failed = true;
2205 /* FIXME: Create a runtime procedure table from the .mdebug section.
2208 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2211 struct bfd_link_info *info;
2213 struct ecoff_debug_info *debug;
2216 /* Handle dynamic relocations when doing an Alpha ELF link. */
2219 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2221 struct bfd_link_info *info;
2223 const Elf_Internal_Rela *relocs;
2227 const char *rel_sec_name;
2228 Elf_Internal_Shdr *symtab_hdr;
2229 struct alpha_elf_link_hash_entry **sym_hashes;
2230 struct alpha_elf_got_entry **local_got_entries;
2231 const Elf_Internal_Rela *rel, *relend;
2235 if (info->relocateable)
2238 dynobj = elf_hash_table(info)->dynobj;
2240 elf_hash_table(info)->dynobj = dynobj = abfd;
2243 rel_sec_name = NULL;
2244 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2245 sym_hashes = alpha_elf_sym_hashes(abfd);
2246 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2249 relend = relocs + sec->reloc_count;
2250 for (rel = relocs; rel < relend; ++rel)
2252 unsigned long r_symndx, r_type;
2253 struct alpha_elf_link_hash_entry *h;
2255 r_symndx = ELF64_R_SYM (rel->r_info);
2256 if (r_symndx < symtab_hdr->sh_info)
2260 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2262 while (h->root.root.type == bfd_link_hash_indirect
2263 || h->root.root.type == bfd_link_hash_warning)
2264 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2266 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2268 r_type = ELF64_R_TYPE (rel->r_info);
2272 case R_ALPHA_LITERAL:
2274 struct alpha_elf_got_entry *gotent;
2279 /* Search for and possibly create a got entry. */
2280 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2281 if (gotent->gotobj == abfd &&
2282 gotent->addend == rel->r_addend)
2287 amt = sizeof (struct alpha_elf_got_entry);
2288 gotent = ((struct alpha_elf_got_entry *)
2289 bfd_alloc (abfd, amt));
2293 gotent->gotobj = abfd;
2294 gotent->addend = rel->r_addend;
2295 gotent->got_offset = -1;
2297 gotent->use_count = 1;
2299 gotent->next = h->got_entries;
2300 h->got_entries = gotent;
2302 alpha_elf_tdata (abfd)->total_got_entries++;
2305 gotent->use_count += 1;
2309 /* This is a local .got entry -- record for merge. */
2310 if (!local_got_entries)
2313 size = symtab_hdr->sh_info;
2314 size *= sizeof (struct alpha_elf_got_entry *);
2316 local_got_entries = ((struct alpha_elf_got_entry **)
2317 bfd_alloc (abfd, size));
2318 if (!local_got_entries)
2321 memset (local_got_entries, 0, (size_t) size);
2322 alpha_elf_tdata (abfd)->local_got_entries =
2326 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2327 gotent != NULL && gotent->addend != rel->r_addend;
2328 gotent = gotent->next)
2332 amt = sizeof (struct alpha_elf_got_entry);
2333 gotent = ((struct alpha_elf_got_entry *)
2334 bfd_alloc (abfd, amt));
2338 gotent->gotobj = abfd;
2339 gotent->addend = rel->r_addend;
2340 gotent->got_offset = -1;
2342 gotent->use_count = 1;
2344 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2345 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2347 alpha_elf_tdata(abfd)->total_got_entries++;
2348 alpha_elf_tdata(abfd)->n_local_got_entries++;
2351 gotent->use_count += 1;
2354 /* Remember how this literal is used from its LITUSEs.
2355 This will be important when it comes to decide if we can
2356 create a .plt entry for a function symbol. */
2358 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2363 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2364 flags |= 1 << rel->r_addend;
2366 while (rel+1 < relend &&
2367 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2371 /* No LITUSEs -- presumably the address is not being
2372 loaded for nothing. */
2373 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2376 gotent->flags |= flags;
2379 /* Make a guess as to whether a .plt entry will be needed. */
2380 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2381 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2383 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2388 case R_ALPHA_GPDISP:
2389 case R_ALPHA_GPREL16:
2390 case R_ALPHA_GPREL32:
2391 case R_ALPHA_GPRELHIGH:
2392 case R_ALPHA_GPRELLOW:
2393 /* We don't actually use the .got here, but the sections must
2394 be created before the linker maps input sections to output
2398 if (!elf64_alpha_create_got_section (abfd, info))
2401 /* Make sure the object's gotobj is set to itself so
2402 that we default to every object with its own .got.
2403 We'll merge .gots later once we've collected each
2405 alpha_elf_tdata(abfd)->gotobj = abfd;
2411 case R_ALPHA_SREL16:
2412 case R_ALPHA_SREL32:
2413 case R_ALPHA_SREL64:
2418 case R_ALPHA_REFLONG:
2419 case R_ALPHA_REFQUAD:
2420 if (rel_sec_name == NULL)
2422 rel_sec_name = (bfd_elf_string_from_elf_section
2423 (abfd, elf_elfheader(abfd)->e_shstrndx,
2424 elf_section_data(sec)->rel_hdr.sh_name));
2425 if (rel_sec_name == NULL)
2428 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2429 && strcmp (bfd_get_section_name (abfd, sec),
2430 rel_sec_name+5) == 0);
2433 /* We need to create the section here now whether we eventually
2434 use it or not so that it gets mapped to an output section by
2435 the linker. If not used, we'll kill it in
2436 size_dynamic_sections. */
2439 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2444 sreloc = bfd_make_section (dynobj, rel_sec_name);
2445 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2446 | SEC_LINKER_CREATED | SEC_READONLY);
2447 if (sec->flags & SEC_ALLOC)
2448 flags |= SEC_ALLOC | SEC_LOAD;
2450 || !bfd_set_section_flags (dynobj, sreloc, flags)
2451 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2458 /* Since we havn't seen all of the input symbols yet, we
2459 don't know whether we'll actually need a dynamic relocation
2460 entry for this reloc. So make a record of it. Once we
2461 find out if this thing needs dynamic relocation we'll
2462 expand the relocation sections by the appropriate amount. */
2464 struct alpha_elf_reloc_entry *rent;
2466 for (rent = h->reloc_entries; rent; rent = rent->next)
2467 if (rent->rtype == r_type && rent->srel == sreloc)
2472 amt = sizeof (struct alpha_elf_reloc_entry);
2473 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
2477 rent->srel = sreloc;
2478 rent->rtype = r_type;
2480 rent->reltext = (sec->flags & SEC_READONLY) != 0;
2482 rent->next = h->reloc_entries;
2483 h->reloc_entries = rent;
2488 else if (info->shared && (sec->flags & SEC_ALLOC))
2490 /* If this is a shared library, and the section is to be
2491 loaded into memory, we need a RELATIVE reloc. */
2492 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2493 if (sec->flags & SEC_READONLY)
2494 info->flags |= DF_TEXTREL;
2503 /* Adjust a symbol defined by a dynamic object and referenced by a
2504 regular object. The current definition is in some section of the
2505 dynamic object, but we're not including those sections. We have to
2506 change the definition to something the rest of the link can
2510 elf64_alpha_adjust_dynamic_symbol (info, h)
2511 struct bfd_link_info *info;
2512 struct elf_link_hash_entry *h;
2516 struct alpha_elf_link_hash_entry *ah;
2518 dynobj = elf_hash_table(info)->dynobj;
2519 ah = (struct alpha_elf_link_hash_entry *)h;
2521 /* Now that we've seen all of the input symbols, finalize our decision
2522 about whether this symbol should get a .plt entry. */
2524 if (h->root.type != bfd_link_hash_undefweak
2525 && alpha_elf_dynamic_symbol_p (h, info)
2526 && ((h->type == STT_FUNC
2527 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2528 || (h->type == STT_NOTYPE
2529 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2530 /* Don't prevent otherwise valid programs from linking by attempting
2531 to create a new .got entry somewhere. A Correct Solution would be
2532 to add a new .got section to a new object file and let it be merged
2533 somewhere later. But for now don't bother. */
2536 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2538 s = bfd_get_section_by_name(dynobj, ".plt");
2539 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2542 /* The first bit of the .plt is reserved. */
2543 if (s->_raw_size == 0)
2544 s->_raw_size = PLT_HEADER_SIZE;
2546 h->plt.offset = s->_raw_size;
2547 s->_raw_size += PLT_ENTRY_SIZE;
2549 /* If this symbol is not defined in a regular file, and we are not
2550 generating a shared library, then set the symbol to the location
2551 in the .plt. This is required to make function pointers compare
2552 equal between the normal executable and the shared library. */
2554 && h->root.type != bfd_link_hash_defweak)
2556 h->root.u.def.section = s;
2557 h->root.u.def.value = h->plt.offset;
2560 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2561 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2562 BFD_ASSERT (s != NULL);
2563 s->_raw_size += sizeof (Elf64_External_Rela);
2568 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2570 /* If this is a weak symbol, and there is a real definition, the
2571 processor independent code will have arranged for us to see the
2572 real definition first, and we can just use the same value. */
2573 if (h->weakdef != NULL)
2575 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2576 || h->weakdef->root.type == bfd_link_hash_defweak);
2577 h->root.u.def.section = h->weakdef->root.u.def.section;
2578 h->root.u.def.value = h->weakdef->root.u.def.value;
2582 /* This is a reference to a symbol defined by a dynamic object which
2583 is not a function. The Alpha, since it uses .got entries for all
2584 symbols even in regular objects, does not need the hackery of a
2585 .dynbss section and COPY dynamic relocations. */
2590 /* Symbol versioning can create new symbols, and make our old symbols
2591 indirect to the new ones. Consolidate the got and reloc information
2592 in these situations. */
2595 elf64_alpha_merge_ind_symbols (hi, dummy)
2596 struct alpha_elf_link_hash_entry *hi;
2597 PTR dummy ATTRIBUTE_UNUSED;
2599 struct alpha_elf_link_hash_entry *hs;
2601 if (hi->root.root.type != bfd_link_hash_indirect)
2605 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2606 } while (hs->root.root.type == bfd_link_hash_indirect);
2608 /* Merge the flags. Whee. */
2610 hs->flags |= hi->flags;
2612 /* Merge the .got entries. Cannibalize the old symbol's list in
2613 doing so, since we don't need it anymore. */
2615 if (hs->got_entries == NULL)
2616 hs->got_entries = hi->got_entries;
2619 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2621 gsh = hs->got_entries;
2622 for (gi = hi->got_entries; gi ; gi = gin)
2625 for (gs = gsh; gs ; gs = gs->next)
2626 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2628 gi->next = hs->got_entries;
2629 hs->got_entries = gi;
2633 hi->got_entries = NULL;
2635 /* And similar for the reloc entries. */
2637 if (hs->reloc_entries == NULL)
2638 hs->reloc_entries = hi->reloc_entries;
2641 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2643 rsh = hs->reloc_entries;
2644 for (ri = hi->reloc_entries; ri ; ri = rin)
2647 for (rs = rsh; rs ; rs = rs->next)
2648 if (ri->rtype == rs->rtype)
2650 rs->count += ri->count;
2653 ri->next = hs->reloc_entries;
2654 hs->reloc_entries = ri;
2658 hi->reloc_entries = NULL;
2663 /* Is it possible to merge two object file's .got tables? */
2666 elf64_alpha_can_merge_gots (a, b)
2669 int total = alpha_elf_tdata (a)->total_got_entries;
2672 /* Trivial quick fallout test. */
2673 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2676 /* By their nature, local .got entries cannot be merged. */
2677 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2680 /* Failing the common trivial comparison, we must effectively
2681 perform the merge. Not actually performing the merge means that
2682 we don't have to store undo information in case we fail. */
2683 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2685 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2686 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2689 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2690 for (i = 0; i < n; ++i)
2692 struct alpha_elf_got_entry *ae, *be;
2693 struct alpha_elf_link_hash_entry *h;
2696 while (h->root.root.type == bfd_link_hash_indirect
2697 || h->root.root.type == bfd_link_hash_warning)
2698 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2700 for (be = h->got_entries; be ; be = be->next)
2702 if (be->use_count == 0)
2704 if (be->gotobj != b)
2707 for (ae = h->got_entries; ae ; ae = ae->next)
2708 if (ae->gotobj == a && ae->addend == be->addend)
2711 if (++total > MAX_GOT_ENTRIES)
2721 /* Actually merge two .got tables. */
2724 elf64_alpha_merge_gots (a, b)
2727 int total = alpha_elf_tdata (a)->total_got_entries;
2730 /* Remember local expansion. */
2732 int e = alpha_elf_tdata (b)->n_local_got_entries;
2734 alpha_elf_tdata (a)->n_local_got_entries += e;
2737 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2739 struct alpha_elf_got_entry **local_got_entries;
2740 struct alpha_elf_link_hash_entry **hashes;
2741 Elf_Internal_Shdr *symtab_hdr;
2744 /* Let the local .got entries know they are part of a new subsegment. */
2745 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2746 if (local_got_entries)
2748 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2749 for (i = 0; i < n; ++i)
2751 struct alpha_elf_got_entry *ent;
2752 for (ent = local_got_entries[i]; ent; ent = ent->next)
2757 /* Merge the global .got entries. */
2758 hashes = alpha_elf_sym_hashes (bsub);
2759 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2761 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2762 for (i = 0; i < n; ++i)
2764 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2765 struct alpha_elf_link_hash_entry *h;
2768 while (h->root.root.type == bfd_link_hash_indirect
2769 || h->root.root.type == bfd_link_hash_warning)
2770 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2772 start = &h->got_entries;
2773 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2775 if (be->use_count == 0)
2780 if (be->gotobj != b)
2783 for (ae = *start; ae ; ae = ae->next)
2784 if (ae->gotobj == a && ae->addend == be->addend)
2786 ae->flags |= be->flags;
2787 ae->use_count += be->use_count;
2798 alpha_elf_tdata (bsub)->gotobj = a;
2800 alpha_elf_tdata (a)->total_got_entries = total;
2802 /* Merge the two in_got chains. */
2807 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2810 alpha_elf_tdata (bsub)->in_got_link_next = b;
2814 /* Calculate the offsets for the got entries. */
2817 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2818 struct alpha_elf_link_hash_entry *h;
2819 PTR arg ATTRIBUTE_UNUSED;
2821 struct alpha_elf_got_entry *gotent;
2823 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2824 if (gotent->use_count > 0)
2827 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2829 gotent->got_offset = *plge;
2837 elf64_alpha_calc_got_offsets (info)
2838 struct bfd_link_info *info;
2840 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2842 /* First, zero out the .got sizes, as we may be recalculating the
2843 .got after optimizing it. */
2844 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2845 alpha_elf_tdata(i)->got->_raw_size = 0;
2847 /* Next, fill in the offsets for all the global entries. */
2848 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2849 elf64_alpha_calc_got_offsets_for_symbol,
2852 /* Finally, fill in the offsets for the local entries. */
2853 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2855 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2858 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2860 struct alpha_elf_got_entry **local_got_entries, *gotent;
2863 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2864 if (!local_got_entries)
2867 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2868 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2869 if (gotent->use_count > 0)
2871 gotent->got_offset = got_offset;
2876 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2877 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2881 /* Constructs the gots. */
2884 elf64_alpha_size_got_sections (output_bfd, info)
2885 bfd *output_bfd ATTRIBUTE_UNUSED;
2886 struct bfd_link_info *info;
2888 bfd *i, *got_list, *cur_got_obj = NULL;
2889 int something_changed = 0;
2891 got_list = alpha_elf_hash_table (info)->got_list;
2893 /* On the first time through, pretend we have an existing got list
2894 consisting of all of the input files. */
2895 if (got_list == NULL)
2897 for (i = info->input_bfds; i ; i = i->link_next)
2899 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2900 if (this_got == NULL)
2903 /* We are assuming no merging has yet ocurred. */
2904 BFD_ASSERT (this_got == i);
2906 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2908 /* Yikes! A single object file has too many entries. */
2909 (*_bfd_error_handler)
2910 (_("%s: .got subsegment exceeds 64K (size %d)"),
2911 bfd_archive_filename (i),
2912 alpha_elf_tdata (this_got)->total_got_entries * 8);
2916 if (got_list == NULL)
2917 got_list = this_got;
2919 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2920 cur_got_obj = this_got;
2923 /* Strange degenerate case of no got references. */
2924 if (got_list == NULL)
2927 alpha_elf_hash_table (info)->got_list = got_list;
2929 /* Force got offsets to be recalculated. */
2930 something_changed = 1;
2933 cur_got_obj = got_list;
2934 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2937 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2939 elf64_alpha_merge_gots (cur_got_obj, i);
2940 i = alpha_elf_tdata(i)->got_link_next;
2941 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2942 something_changed = 1;
2947 i = alpha_elf_tdata(i)->got_link_next;
2951 /* Once the gots have been merged, fill in the got offsets for
2952 everything therein. */
2953 if (1 || something_changed)
2954 elf64_alpha_calc_got_offsets (info);
2960 elf64_alpha_always_size_sections (output_bfd, info)
2962 struct bfd_link_info *info;
2966 if (info->relocateable)
2969 /* First, take care of the indirect symbols created by versioning. */
2970 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2971 elf64_alpha_merge_ind_symbols,
2974 if (!elf64_alpha_size_got_sections (output_bfd, info))
2977 /* Allocate space for all of the .got subsections. */
2978 i = alpha_elf_hash_table (info)->got_list;
2979 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2981 asection *s = alpha_elf_tdata(i)->got;
2982 if (s->_raw_size > 0)
2984 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
2985 if (s->contents == NULL)
2993 /* Work out the sizes of the dynamic relocation entries. */
2996 elf64_alpha_calc_dynrel_sizes (h, info)
2997 struct alpha_elf_link_hash_entry *h;
2998 struct bfd_link_info *info;
3000 /* If the symbol was defined as a common symbol in a regular object
3001 file, and there was no definition in any dynamic object, then the
3002 linker will have allocated space for the symbol in a common
3003 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3004 set. This is done for dynamic symbols in
3005 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3006 symbols, somehow. */
3007 if (((h->root.elf_link_hash_flags
3008 & (ELF_LINK_HASH_DEF_REGULAR
3009 | ELF_LINK_HASH_REF_REGULAR
3010 | ELF_LINK_HASH_DEF_DYNAMIC))
3011 == ELF_LINK_HASH_REF_REGULAR)
3012 && (h->root.root.type == bfd_link_hash_defined
3013 || h->root.root.type == bfd_link_hash_defweak)
3014 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3016 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3019 /* If the symbol is dynamic, we'll need all the relocations in their
3020 natural form. If this is a shared object, and it has been forced
3021 local, we'll need the same number of RELATIVE relocations. */
3023 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3025 struct alpha_elf_reloc_entry *relent;
3027 struct alpha_elf_got_entry *gotent;
3028 bfd_size_type count;
3031 for (relent = h->reloc_entries; relent; relent = relent->next)
3032 if (relent->rtype == R_ALPHA_REFLONG
3033 || relent->rtype == R_ALPHA_REFQUAD)
3035 relent->srel->_raw_size +=
3036 sizeof (Elf64_External_Rela) * relent->count;
3037 if (relent->reltext)
3038 info->flags |= DT_TEXTREL;
3041 dynobj = elf_hash_table(info)->dynobj;
3044 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3047 /* If we are using a .plt entry, subtract one, as the first
3048 reference uses a .rela.plt entry instead. */
3049 if (h->root.plt.offset != MINUS_ONE)
3054 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3055 BFD_ASSERT (srel != NULL);
3056 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3063 /* Set the sizes of the dynamic sections. */
3066 elf64_alpha_size_dynamic_sections (output_bfd, info)
3067 bfd *output_bfd ATTRIBUTE_UNUSED;
3068 struct bfd_link_info *info;
3074 dynobj = elf_hash_table(info)->dynobj;
3075 BFD_ASSERT(dynobj != NULL);
3077 if (elf_hash_table (info)->dynamic_sections_created)
3079 /* Set the contents of the .interp section to the interpreter. */
3082 s = bfd_get_section_by_name (dynobj, ".interp");
3083 BFD_ASSERT (s != NULL);
3084 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3085 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3088 /* Now that we've seen all of the input files, we can decide which
3089 symbols need dynamic relocation entries and which don't. We've
3090 collected information in check_relocs that we can now apply to
3091 size the dynamic relocation sections. */
3092 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3093 elf64_alpha_calc_dynrel_sizes,
3096 /* When building shared libraries, each local .got entry needs a
3102 bfd_size_type count;
3104 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3105 BFD_ASSERT (srel != NULL);
3107 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3109 i = alpha_elf_tdata(i)->got_link_next)
3110 count += alpha_elf_tdata(i)->n_local_got_entries;
3112 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3115 /* else we're not dynamic and by definition we don't need such things. */
3117 /* The check_relocs and adjust_dynamic_symbol entry points have
3118 determined the sizes of the various dynamic sections. Allocate
3121 for (s = dynobj->sections; s != NULL; s = s->next)
3126 if (!(s->flags & SEC_LINKER_CREATED))
3129 /* It's OK to base decisions on the section name, because none
3130 of the dynobj section names depend upon the input files. */
3131 name = bfd_get_section_name (dynobj, s);
3133 /* If we don't need this section, strip it from the output file.
3134 This is to handle .rela.bss and .rela.plt. We must create it
3135 in create_dynamic_sections, because it must be created before
3136 the linker maps input sections to output sections. The
3137 linker does that before adjust_dynamic_symbol is called, and
3138 it is that function which decides whether anything needs to
3139 go into these sections. */
3143 if (strncmp (name, ".rela", 5) == 0)
3145 strip = (s->_raw_size == 0);
3149 if (strcmp(name, ".rela.plt") == 0)
3152 /* We use the reloc_count field as a counter if we need
3153 to copy relocs into the output file. */
3157 else if (strcmp (name, ".plt") != 0)
3159 /* It's not one of our dynamic sections, so don't allocate space. */
3164 _bfd_strip_section_from_output (info, s);
3167 /* Allocate memory for the section contents. */
3168 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3169 if (s->contents == NULL && s->_raw_size != 0)
3174 if (elf_hash_table (info)->dynamic_sections_created)
3176 /* Add some entries to the .dynamic section. We fill in the
3177 values later, in elf64_alpha_finish_dynamic_sections, but we
3178 must add the entries now so that we get the correct size for
3179 the .dynamic section. The DT_DEBUG entry is filled in by the
3180 dynamic linker and used by the debugger. */
3181 #define add_dynamic_entry(TAG, VAL) \
3182 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3186 if (!add_dynamic_entry (DT_DEBUG, 0))
3190 if (!add_dynamic_entry (DT_PLTGOT, 0))
3195 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3196 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3197 || !add_dynamic_entry (DT_JMPREL, 0))
3201 if (!add_dynamic_entry (DT_RELA, 0)
3202 || !add_dynamic_entry (DT_RELASZ, 0)
3203 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3206 if (info->flags & DF_TEXTREL)
3208 if (!add_dynamic_entry (DT_TEXTREL, 0))
3212 #undef add_dynamic_entry
3217 /* Relocate an Alpha ELF section. */
3220 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3221 contents, relocs, local_syms, local_sections)
3223 struct bfd_link_info *info;
3225 asection *input_section;
3227 Elf_Internal_Rela *relocs;
3228 Elf_Internal_Sym *local_syms;
3229 asection **local_sections;
3231 Elf_Internal_Shdr *symtab_hdr;
3232 Elf_Internal_Rela *rel;
3233 Elf_Internal_Rela *relend;
3234 asection *sec, *sgot, *srel, *srelgot;
3235 bfd *dynobj, *gotobj;
3237 boolean ret_val = true;
3239 srelgot = srel = NULL;
3240 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3241 dynobj = elf_hash_table (info)->dynobj;
3244 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3247 /* Find the gp value for this input bfd. */
3250 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3253 sgot = alpha_elf_tdata (gotobj)->got;
3254 gp = _bfd_get_gp_value (gotobj);
3257 gp = (sgot->output_section->vma
3258 + sgot->output_offset
3260 _bfd_set_gp_value (gotobj, gp);
3265 relend = relocs + input_section->reloc_count;
3266 for (; rel < relend; rel++)
3269 reloc_howto_type *howto;
3270 unsigned long r_symndx;
3271 struct alpha_elf_link_hash_entry *h;
3272 Elf_Internal_Sym *sym;
3275 bfd_reloc_status_type r;
3277 r_type = ELF64_R_TYPE(rel->r_info);
3278 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3280 bfd_set_error (bfd_error_bad_value);
3283 howto = elf64_alpha_howto_table + r_type;
3285 r_symndx = ELF64_R_SYM(rel->r_info);
3287 if (info->relocateable)
3289 /* This is a relocateable link. We don't have to change
3290 anything, unless the reloc is against a section symbol,
3291 in which case we have to adjust according to where the
3292 section symbol winds up in the output section. */
3294 /* The symbol associated with GPDISP and LITUSE is
3295 immaterial. Only the addend is significant. */
3296 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3299 if (r_symndx < symtab_hdr->sh_info)
3301 sym = local_syms + r_symndx;
3302 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3304 sec = local_sections[r_symndx];
3305 rel->r_addend += sec->output_offset + sym->st_value;
3312 /* This is a final link. */
3318 if (r_symndx < symtab_hdr->sh_info)
3320 sym = local_syms + r_symndx;
3321 sec = local_sections[r_symndx];
3322 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3326 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3328 while (h->root.root.type == bfd_link_hash_indirect
3329 || h->root.root.type == bfd_link_hash_warning)
3330 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3332 if (h->root.root.type == bfd_link_hash_defined
3333 || h->root.root.type == bfd_link_hash_defweak)
3335 sec = h->root.root.u.def.section;
3337 if (sec->output_section == NULL)
3341 relocation = (h->root.root.u.def.value
3342 + sec->output_section->vma
3343 + sec->output_offset);
3346 else if (h->root.root.type == bfd_link_hash_undefweak)
3348 else if (info->shared
3349 && (!info->symbolic || info->allow_shlib_undefined)
3350 && !info->no_undefined
3351 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3355 if (!((*info->callbacks->undefined_symbol)
3356 (info, h->root.root.root.string, input_bfd,
3357 input_section, rel->r_offset,
3358 (!info->shared || info->no_undefined
3359 || ELF_ST_VISIBILITY (h->root.other)))))
3364 addend = rel->r_addend;
3368 case R_ALPHA_GPDISP:
3370 bfd_byte *p_ldah, *p_lda;
3372 BFD_ASSERT(gp != 0);
3374 relocation = (input_section->output_section->vma
3375 + input_section->output_offset
3378 p_ldah = contents + rel->r_offset - input_section->vma;
3379 p_lda = p_ldah + rel->r_addend;
3381 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3386 case R_ALPHA_LITERAL:
3388 struct alpha_elf_got_entry *gotent;
3389 boolean dynamic_symbol;
3391 BFD_ASSERT(sgot != NULL);
3392 BFD_ASSERT(gp != 0);
3396 gotent = h->got_entries;
3397 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3401 gotent = (alpha_elf_tdata(input_bfd)->
3402 local_got_entries[r_symndx]);
3403 dynamic_symbol = false;
3405 /* Need to adjust local GOT entries' addends for SEC_MERGE
3406 unless it has been done already. */
3407 if ((sec->flags & SEC_MERGE)
3408 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3409 && elf_section_data (sec)->merge_info
3410 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3412 struct alpha_elf_got_entry *ent;
3415 for (ent = gotent; ent; ent = ent->next)
3417 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3418 if (ent->use_count == 0)
3422 _bfd_merged_section_offset (output_bfd, &msec,
3423 elf_section_data (sec)->
3428 ent->addend -= sym->st_value;
3429 ent->addend += msec->output_section->vma
3430 + msec->output_offset
3431 - sec->output_section->vma
3432 - sec->output_offset;
3437 BFD_ASSERT(gotent != NULL);
3439 while (gotent->gotobj != gotobj || gotent->addend != addend)
3440 gotent = gotent->next;
3442 BFD_ASSERT(gotent->use_count >= 1);
3444 /* Initialize the .got entry's value. */
3445 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3447 bfd_put_64 (output_bfd, relocation + addend,
3448 sgot->contents + gotent->got_offset);
3450 /* If the symbol has been forced local, output a
3451 RELATIVE reloc, otherwise it will be handled in
3452 finish_dynamic_symbol. */
3453 if (info->shared && !dynamic_symbol)
3455 Elf_Internal_Rela outrel;
3457 BFD_ASSERT(srelgot != NULL);
3459 outrel.r_offset = (sgot->output_section->vma
3460 + sgot->output_offset
3461 + gotent->got_offset);
3462 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3463 outrel.r_addend = relocation + addend;
3465 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3466 ((Elf64_External_Rela *)
3468 + srelgot->reloc_count++);
3469 BFD_ASSERT (sizeof (Elf64_External_Rela)
3470 * srelgot->reloc_count
3471 <= srelgot->_cooked_size);
3474 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3477 /* Figure the gprel relocation. */
3479 relocation = (sgot->output_section->vma
3480 + sgot->output_offset
3481 + gotent->got_offset);
3484 /* overflow handled by _bfd_final_link_relocate */
3487 case R_ALPHA_GPREL16:
3488 case R_ALPHA_GPREL32:
3489 case R_ALPHA_GPRELLOW:
3490 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3492 (*_bfd_error_handler)
3493 (_("%s: gp-relative relocation against dynamic symbol %s"),
3494 bfd_archive_filename (input_bfd), h->root.root.root.string);
3497 BFD_ASSERT(gp != 0);
3501 case R_ALPHA_GPRELHIGH:
3502 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3504 (*_bfd_error_handler)
3505 (_("%s: gp-relative relocation against dynamic symbol %s"),
3506 bfd_archive_filename (input_bfd), h->root.root.root.string);
3509 BFD_ASSERT(gp != 0);
3511 relocation += addend;
3513 relocation = (((bfd_signed_vma) relocation >> 16)
3514 + ((relocation >> 15) & 1));
3518 /* A call to a dynamic symbol is definitely out of range of
3519 the 16-bit displacement. Don't bother writing anything. */
3520 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3527 case R_ALPHA_BRADDR:
3528 /* The regular PC-relative stuff measures from the start of
3529 the instruction rather than the end. */
3533 case R_ALPHA_REFLONG:
3534 case R_ALPHA_REFQUAD:
3536 Elf_Internal_Rela outrel;
3539 /* Careful here to remember RELATIVE relocations for global
3540 variables for symbolic shared objects. */
3542 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3544 BFD_ASSERT(h->root.dynindx != -1);
3545 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3546 outrel.r_addend = addend;
3547 addend = 0, relocation = 0;
3549 else if (info->shared
3551 && (input_section->flags & SEC_ALLOC))
3553 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3554 outrel.r_addend = relocation + addend;
3563 name = (bfd_elf_string_from_elf_section
3564 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3565 elf_section_data(input_section)->rel_hdr.sh_name));
3566 BFD_ASSERT(name != NULL);
3568 srel = bfd_get_section_by_name (dynobj, name);
3569 BFD_ASSERT(srel != NULL);
3574 if (elf_section_data (input_section)->stab_info == NULL)
3575 outrel.r_offset = rel->r_offset;
3580 off = (_bfd_stab_section_offset
3581 (output_bfd, &elf_hash_table (info)->stab_info,
3583 &elf_section_data (input_section)->stab_info,
3585 if (off == (bfd_vma) -1)
3587 outrel.r_offset = off;
3591 outrel.r_offset += (input_section->output_section->vma
3592 + input_section->output_offset);
3594 memset (&outrel, 0, sizeof outrel);
3596 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3597 ((Elf64_External_Rela *)
3599 + srel->reloc_count++);
3600 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3601 <= srel->_cooked_size);
3607 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3608 contents, rel->r_offset, relocation,
3618 case bfd_reloc_overflow:
3623 name = h->root.root.root.string;
3626 name = (bfd_elf_string_from_elf_section
3627 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3631 name = bfd_section_name (input_bfd, sec);
3633 if (! ((*info->callbacks->reloc_overflow)
3634 (info, name, howto->name, (bfd_vma) 0,
3635 input_bfd, input_section, rel->r_offset)))
3641 case bfd_reloc_outofrange:
3649 /* Finish up dynamic symbol handling. We set the contents of various
3650 dynamic sections here. */
3653 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3655 struct bfd_link_info *info;
3656 struct elf_link_hash_entry *h;
3657 Elf_Internal_Sym *sym;
3659 bfd *dynobj = elf_hash_table(info)->dynobj;
3661 if (h->plt.offset != MINUS_ONE)
3663 /* Fill in the .plt entry for this symbol. */
3664 asection *splt, *sgot, *srel;
3665 Elf_Internal_Rela outrel;
3666 bfd_vma got_addr, plt_addr;
3668 struct alpha_elf_got_entry *gotent;
3670 BFD_ASSERT (h->dynindx != -1);
3672 /* The first .got entry will be updated by the .plt with the
3673 address of the target function. */
3674 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3675 BFD_ASSERT (gotent && gotent->addend == 0);
3677 splt = bfd_get_section_by_name (dynobj, ".plt");
3678 BFD_ASSERT (splt != NULL);
3679 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3680 BFD_ASSERT (srel != NULL);
3681 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3682 BFD_ASSERT (sgot != NULL);
3684 got_addr = (sgot->output_section->vma
3685 + sgot->output_offset
3686 + gotent->got_offset);
3687 plt_addr = (splt->output_section->vma
3688 + splt->output_offset
3691 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3693 /* Fill in the entry in the procedure linkage table. */
3695 bfd_vma insn1, insn2, insn3;
3697 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3698 insn2 = PLT_ENTRY_WORD2;
3699 insn3 = PLT_ENTRY_WORD3;
3701 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3702 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3703 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3706 /* Fill in the entry in the .rela.plt section. */
3707 outrel.r_offset = got_addr;
3708 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3709 outrel.r_addend = 0;
3711 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3712 ((Elf64_External_Rela *)srel->contents
3715 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3717 /* Mark the symbol as undefined, rather than as defined in the
3718 .plt section. Leave the value alone. */
3719 sym->st_shndx = SHN_UNDEF;
3722 /* Fill in the entries in the .got. */
3723 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3725 /* Subsequent .got entries will continue to bounce through the .plt. */
3728 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3729 BFD_ASSERT (! info->shared || srel != NULL);
3731 gotent = gotent->next;
3734 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3735 BFD_ASSERT(sgot != NULL);
3736 BFD_ASSERT(gotent->addend == 0);
3738 bfd_put_64 (output_bfd, plt_addr,
3739 sgot->contents + gotent->got_offset);
3743 outrel.r_offset = (sgot->output_section->vma
3744 + sgot->output_offset
3745 + gotent->got_offset);
3746 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3747 outrel.r_addend = plt_addr;
3749 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3750 ((Elf64_External_Rela *)
3752 + srel->reloc_count++);
3753 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3754 <= srel->_cooked_size);
3757 gotent = gotent->next;
3759 while (gotent != NULL);
3762 else if (alpha_elf_dynamic_symbol_p (h, info))
3764 /* Fill in the dynamic relocations for this symbol's .got entries. */
3766 Elf_Internal_Rela outrel;
3767 struct alpha_elf_got_entry *gotent;
3769 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3770 BFD_ASSERT (srel != NULL);
3772 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3773 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3775 gotent = gotent->next)
3777 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3778 outrel.r_offset = (sgot->output_section->vma
3779 + sgot->output_offset
3780 + gotent->got_offset);
3781 outrel.r_addend = gotent->addend;
3783 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3784 ((Elf64_External_Rela *)srel->contents
3785 + srel->reloc_count++));
3786 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3787 <= srel->_cooked_size);
3791 /* Mark some specially defined symbols as absolute. */
3792 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3793 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3794 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3795 sym->st_shndx = SHN_ABS;
3800 /* Finish up the dynamic sections. */
3803 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3805 struct bfd_link_info *info;
3810 dynobj = elf_hash_table (info)->dynobj;
3811 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3813 if (elf_hash_table (info)->dynamic_sections_created)
3816 Elf64_External_Dyn *dyncon, *dynconend;
3818 splt = bfd_get_section_by_name (dynobj, ".plt");
3819 BFD_ASSERT (splt != NULL && sdyn != NULL);
3821 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3822 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3823 for (; dyncon < dynconend; dyncon++)
3825 Elf_Internal_Dyn dyn;
3829 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3844 /* My interpretation of the TIS v1.1 ELF document indicates
3845 that RELASZ should not include JMPREL. This is not what
3846 the rest of the BFD does. It is, however, what the
3847 glibc ld.so wants. Do this fixup here until we found
3848 out who is right. */
3849 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3853 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3858 s = bfd_get_section_by_name (output_bfd, name);
3859 dyn.d_un.d_ptr = (s ? s->vma : 0);
3863 s = bfd_get_section_by_name (output_bfd, name);
3865 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3869 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3872 /* Initialize the PLT0 entry */
3873 if (splt->_raw_size > 0)
3875 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3876 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3877 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3878 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3880 /* The next two words will be filled in by ld.so */
3881 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3882 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
3884 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3892 /* We need to use a special link routine to handle the .mdebug section.
3893 We need to merge all instances of these sections together, not write
3894 them all out sequentially. */
3897 elf64_alpha_final_link (abfd, info)
3899 struct bfd_link_info *info;
3902 struct bfd_link_order *p;
3903 asection *mdebug_sec;
3904 struct ecoff_debug_info debug;
3905 const struct ecoff_debug_swap *swap
3906 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3907 HDRR *symhdr = &debug.symbolic_header;
3908 PTR mdebug_handle = NULL;
3910 /* Go through the sections and collect the mdebug information. */
3912 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
3914 if (strcmp (o->name, ".mdebug") == 0)
3916 struct extsym_info einfo;
3918 /* We have found the .mdebug section in the output file.
3919 Look through all the link_orders comprising it and merge
3920 the information together. */
3921 symhdr->magic = swap->sym_magic;
3922 /* FIXME: What should the version stamp be? */
3924 symhdr->ilineMax = 0;
3928 symhdr->isymMax = 0;
3929 symhdr->ioptMax = 0;
3930 symhdr->iauxMax = 0;
3932 symhdr->issExtMax = 0;
3935 symhdr->iextMax = 0;
3937 /* We accumulate the debugging information itself in the
3938 debug_info structure. */
3940 debug.external_dnr = NULL;
3941 debug.external_pdr = NULL;
3942 debug.external_sym = NULL;
3943 debug.external_opt = NULL;
3944 debug.external_aux = NULL;
3946 debug.ssext = debug.ssext_end = NULL;
3947 debug.external_fdr = NULL;
3948 debug.external_rfd = NULL;
3949 debug.external_ext = debug.external_ext_end = NULL;
3951 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
3952 if (mdebug_handle == (PTR) NULL)
3961 static const char * const name[] =
3963 ".text", ".init", ".fini", ".data",
3964 ".rodata", ".sdata", ".sbss", ".bss"
3966 static const int sc[] = { scText, scInit, scFini, scData,
3967 scRData, scSData, scSBss, scBss };
3970 esym.cobol_main = 0;
3974 esym.asym.iss = issNil;
3975 esym.asym.st = stLocal;
3976 esym.asym.reserved = 0;
3977 esym.asym.index = indexNil;
3978 for (i = 0; i < 8; i++)
3980 esym.asym.sc = sc[i];
3981 s = bfd_get_section_by_name (abfd, name[i]);
3984 esym.asym.value = s->vma;
3985 last = s->vma + s->_raw_size;
3988 esym.asym.value = last;
3990 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
3996 for (p = o->link_order_head;
3997 p != (struct bfd_link_order *) NULL;
4000 asection *input_section;
4002 const struct ecoff_debug_swap *input_swap;
4003 struct ecoff_debug_info input_debug;
4007 if (p->type != bfd_indirect_link_order)
4009 if (p->type == bfd_fill_link_order)
4014 input_section = p->u.indirect.section;
4015 input_bfd = input_section->owner;
4017 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4018 || (get_elf_backend_data (input_bfd)
4019 ->elf_backend_ecoff_debug_swap) == NULL)
4021 /* I don't know what a non ALPHA ELF bfd would be
4022 doing with a .mdebug section, but I don't really
4023 want to deal with it. */
4027 input_swap = (get_elf_backend_data (input_bfd)
4028 ->elf_backend_ecoff_debug_swap);
4030 BFD_ASSERT (p->size == input_section->_raw_size);
4032 /* The ECOFF linking code expects that we have already
4033 read in the debugging information and set up an
4034 ecoff_debug_info structure, so we do that now. */
4035 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4039 if (! (bfd_ecoff_debug_accumulate
4040 (mdebug_handle, abfd, &debug, swap, input_bfd,
4041 &input_debug, input_swap, info)))
4044 /* Loop through the external symbols. For each one with
4045 interesting information, try to find the symbol in
4046 the linker global hash table and save the information
4047 for the output external symbols. */
4048 eraw_src = input_debug.external_ext;
4049 eraw_end = (eraw_src
4050 + (input_debug.symbolic_header.iextMax
4051 * input_swap->external_ext_size));
4053 eraw_src < eraw_end;
4054 eraw_src += input_swap->external_ext_size)
4058 struct alpha_elf_link_hash_entry *h;
4060 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4061 if (ext.asym.sc == scNil
4062 || ext.asym.sc == scUndefined
4063 || ext.asym.sc == scSUndefined)
4066 name = input_debug.ssext + ext.asym.iss;
4067 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4068 name, false, false, true);
4069 if (h == NULL || h->esym.ifd != -2)
4075 < input_debug.symbolic_header.ifdMax);
4076 ext.ifd = input_debug.ifdmap[ext.ifd];
4082 /* Free up the information we just read. */
4083 free (input_debug.line);
4084 free (input_debug.external_dnr);
4085 free (input_debug.external_pdr);
4086 free (input_debug.external_sym);
4087 free (input_debug.external_opt);
4088 free (input_debug.external_aux);
4089 free (input_debug.ss);
4090 free (input_debug.ssext);
4091 free (input_debug.external_fdr);
4092 free (input_debug.external_rfd);
4093 free (input_debug.external_ext);
4095 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4096 elf_link_input_bfd ignores this section. */
4097 input_section->flags &=~ SEC_HAS_CONTENTS;
4100 /* Build the external symbol information. */
4103 einfo.debug = &debug;
4105 einfo.failed = false;
4106 elf_link_hash_traverse (elf_hash_table (info),
4107 elf64_alpha_output_extsym,
4112 /* Set the size of the .mdebug section. */
4113 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4115 /* Skip this section later on (I don't think this currently
4116 matters, but someday it might). */
4117 o->link_order_head = (struct bfd_link_order *) NULL;
4123 /* Invoke the regular ELF backend linker to do all the work. */
4124 if (! bfd_elf64_bfd_final_link (abfd, info))
4127 /* Now write out the computed sections. */
4129 /* The .got subsections... */
4131 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4132 for (i = alpha_elf_hash_table(info)->got_list;
4134 i = alpha_elf_tdata(i)->got_link_next)
4138 /* elf_bfd_final_link already did everything in dynobj. */
4142 sgot = alpha_elf_tdata(i)->got;
4143 if (! bfd_set_section_contents (abfd, sgot->output_section,
4145 (file_ptr) sgot->output_offset,
4151 if (mdebug_sec != (asection *) NULL)
4153 BFD_ASSERT (abfd->output_has_begun);
4154 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4156 mdebug_sec->filepos))
4159 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4165 static enum elf_reloc_type_class
4166 elf64_alpha_reloc_type_class (rela)
4167 const Elf_Internal_Rela *rela;
4169 switch ((int) ELF64_R_TYPE (rela->r_info))
4171 case R_ALPHA_RELATIVE:
4172 return reloc_class_relative;
4173 case R_ALPHA_JMP_SLOT:
4174 return reloc_class_plt;
4176 return reloc_class_copy;
4178 return reloc_class_normal;
4182 /* ECOFF swapping routines. These are used when dealing with the
4183 .mdebug section, which is in the ECOFF debugging format. Copied
4184 from elf32-mips.c. */
4185 static const struct ecoff_debug_swap
4186 elf64_alpha_ecoff_debug_swap =
4188 /* Symbol table magic number. */
4190 /* Alignment of debugging information. E.g., 4. */
4192 /* Sizes of external symbolic information. */
4193 sizeof (struct hdr_ext),
4194 sizeof (struct dnr_ext),
4195 sizeof (struct pdr_ext),
4196 sizeof (struct sym_ext),
4197 sizeof (struct opt_ext),
4198 sizeof (struct fdr_ext),
4199 sizeof (struct rfd_ext),
4200 sizeof (struct ext_ext),
4201 /* Functions to swap in external symbolic data. */
4210 _bfd_ecoff_swap_tir_in,
4211 _bfd_ecoff_swap_rndx_in,
4212 /* Functions to swap out external symbolic data. */
4221 _bfd_ecoff_swap_tir_out,
4222 _bfd_ecoff_swap_rndx_out,
4223 /* Function to read in symbolic data. */
4224 elf64_alpha_read_ecoff_info
4227 /* Use a non-standard hash bucket size of 8. */
4229 const struct elf_size_info alpha_elf_size_info =
4231 sizeof (Elf64_External_Ehdr),
4232 sizeof (Elf64_External_Phdr),
4233 sizeof (Elf64_External_Shdr),
4234 sizeof (Elf64_External_Rel),
4235 sizeof (Elf64_External_Rela),
4236 sizeof (Elf64_External_Sym),
4237 sizeof (Elf64_External_Dyn),
4238 sizeof (Elf_External_Note),
4242 ELFCLASS64, EV_CURRENT,
4243 bfd_elf64_write_out_phdrs,
4244 bfd_elf64_write_shdrs_and_ehdr,
4245 bfd_elf64_write_relocs,
4246 bfd_elf64_swap_symbol_out,
4247 bfd_elf64_slurp_reloc_table,
4248 bfd_elf64_slurp_symbol_table,
4249 bfd_elf64_swap_dyn_in,
4250 bfd_elf64_swap_dyn_out,
4257 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4258 #define TARGET_LITTLE_NAME "elf64-alpha"
4259 #define ELF_ARCH bfd_arch_alpha
4260 #define ELF_MACHINE_CODE EM_ALPHA
4261 #define ELF_MAXPAGESIZE 0x10000
4263 #define bfd_elf64_bfd_link_hash_table_create \
4264 elf64_alpha_bfd_link_hash_table_create
4266 #define bfd_elf64_bfd_reloc_type_lookup \
4267 elf64_alpha_bfd_reloc_type_lookup
4268 #define elf_info_to_howto \
4269 elf64_alpha_info_to_howto
4271 #define bfd_elf64_mkobject \
4272 elf64_alpha_mkobject
4273 #define elf_backend_object_p \
4274 elf64_alpha_object_p
4276 #define elf_backend_section_from_shdr \
4277 elf64_alpha_section_from_shdr
4278 #define elf_backend_section_flags \
4279 elf64_alpha_section_flags
4280 #define elf_backend_fake_sections \
4281 elf64_alpha_fake_sections
4283 #define bfd_elf64_bfd_is_local_label_name \
4284 elf64_alpha_is_local_label_name
4285 #define bfd_elf64_find_nearest_line \
4286 elf64_alpha_find_nearest_line
4287 #define bfd_elf64_bfd_relax_section \
4288 elf64_alpha_relax_section
4290 #define elf_backend_add_symbol_hook \
4291 elf64_alpha_add_symbol_hook
4292 #define elf_backend_check_relocs \
4293 elf64_alpha_check_relocs
4294 #define elf_backend_create_dynamic_sections \
4295 elf64_alpha_create_dynamic_sections
4296 #define elf_backend_adjust_dynamic_symbol \
4297 elf64_alpha_adjust_dynamic_symbol
4298 #define elf_backend_always_size_sections \
4299 elf64_alpha_always_size_sections
4300 #define elf_backend_size_dynamic_sections \
4301 elf64_alpha_size_dynamic_sections
4302 #define elf_backend_relocate_section \
4303 elf64_alpha_relocate_section
4304 #define elf_backend_finish_dynamic_symbol \
4305 elf64_alpha_finish_dynamic_symbol
4306 #define elf_backend_finish_dynamic_sections \
4307 elf64_alpha_finish_dynamic_sections
4308 #define bfd_elf64_bfd_final_link \
4309 elf64_alpha_final_link
4310 #define elf_backend_reloc_type_class \
4311 elf64_alpha_reloc_type_class
4313 #define elf_backend_ecoff_debug_swap \
4314 &elf64_alpha_ecoff_debug_swap
4316 #define elf_backend_size_info \
4319 /* A few constants that determine how the .plt section is set up. */
4320 #define elf_backend_want_got_plt 0
4321 #define elf_backend_plt_readonly 0
4322 #define elf_backend_want_plt_sym 1
4323 #define elf_backend_got_header_size 0
4324 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4326 #include "elf64-target.h"