1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* $FreeBSD: src/contrib/binutils/bfd/elf64-alpha.c,v 1.3.2.5 2002/09/01 23:43:38 obrien Exp $ */
23 /* $DragonFly: src/contrib/binutils/bfd/Attic/elf64-alpha.c,v 1.2 2003/06/17 04:23:58 dillon Exp $ */
25 /* We need a published ABI spec for this. Until one comes out, don't
26 assume this'll remain unchanged forever. */
33 #include "elf/alpha.h"
37 #define NO_COFF_RELOCS
38 #define NO_COFF_SYMBOLS
39 #define NO_COFF_LINENOS
41 /* Get the ECOFF swapping routines. Needed for the debug information. */
42 #include "coff/internal.h"
44 #include "coff/symconst.h"
45 #include "coff/ecoff.h"
46 #include "coff/alpha.h"
51 #include "ecoffswap.h"
53 static int alpha_elf_dynamic_symbol_p
54 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
55 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
56 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
57 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
60 static bfd_reloc_status_type elf64_alpha_reloc_nil
61 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
62 static bfd_reloc_status_type elf64_alpha_reloc_bad
63 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
64 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
65 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
66 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
67 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
69 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
70 PARAMS((bfd *, bfd_reloc_code_real_type));
71 static void elf64_alpha_info_to_howto
72 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
74 static boolean elf64_alpha_mkobject
76 static boolean elf64_alpha_object_p
78 static boolean elf64_alpha_section_from_shdr
79 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
80 static boolean elf64_alpha_section_flags
81 PARAMS((flagword *, Elf64_Internal_Shdr *));
82 static boolean elf64_alpha_fake_sections
83 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
84 static boolean elf64_alpha_create_got_section
85 PARAMS((bfd *, struct bfd_link_info *));
86 static boolean elf64_alpha_create_dynamic_sections
87 PARAMS((bfd *, struct bfd_link_info *));
89 static boolean elf64_alpha_read_ecoff_info
90 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
91 static boolean elf64_alpha_is_local_label_name
92 PARAMS((bfd *, const char *));
93 static boolean elf64_alpha_find_nearest_line
94 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
95 const char **, unsigned int *));
97 #if defined(__STDC__) || defined(ALMOST_STDC)
98 struct alpha_elf_link_hash_entry;
101 static boolean elf64_alpha_output_extsym
102 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
104 static boolean elf64_alpha_can_merge_gots
105 PARAMS((bfd *, bfd *));
106 static void elf64_alpha_merge_gots
107 PARAMS((bfd *, bfd *));
108 static boolean elf64_alpha_calc_got_offsets_for_symbol
109 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
110 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
111 static boolean elf64_alpha_size_got_sections
112 PARAMS ((bfd *, struct bfd_link_info *));
113 static boolean elf64_alpha_always_size_sections
114 PARAMS ((bfd *, struct bfd_link_info *));
115 static boolean elf64_alpha_calc_dynrel_sizes
116 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
117 static boolean elf64_alpha_add_symbol_hook
118 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
119 const char **, flagword *, asection **, bfd_vma *));
120 static boolean elf64_alpha_check_relocs
121 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
122 const Elf_Internal_Rela *));
123 static boolean elf64_alpha_adjust_dynamic_symbol
124 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
125 static boolean elf64_alpha_size_dynamic_sections
126 PARAMS((bfd *, struct bfd_link_info *));
127 static boolean elf64_alpha_relocate_section
128 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
129 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
130 static boolean elf64_alpha_finish_dynamic_symbol
131 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
132 Elf_Internal_Sym *));
133 static boolean elf64_alpha_finish_dynamic_sections
134 PARAMS((bfd *, struct bfd_link_info *));
135 static boolean elf64_alpha_final_link
136 PARAMS((bfd *, struct bfd_link_info *));
137 static boolean elf64_alpha_merge_ind_symbols
138 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
139 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
140 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
141 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
142 PARAMS ((const Elf_Internal_Rela *));
144 struct alpha_elf_link_hash_entry
146 struct elf_link_hash_entry root;
148 /* External symbol information. */
151 /* Cumulative flags for all the .got entries. */
154 /* Contexts (LITUSE) in which a literal was referenced. */
155 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
156 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
157 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
158 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
160 /* Used to implement multiple .got subsections. */
161 struct alpha_elf_got_entry
163 struct alpha_elf_got_entry *next;
165 /* which .got subsection? */
168 /* the addend in effect for this entry. */
171 /* the .got offset for this entry. */
176 /* Additional flags. */
177 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
178 #define ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED 0x20
183 /* used to count non-got, non-plt relocations for delayed sizing
184 of relocation sections. */
185 struct alpha_elf_reloc_entry
187 struct alpha_elf_reloc_entry *next;
189 /* which .reloc section? */
192 /* what kind of relocation? */
195 /* is this against read-only section? */
196 unsigned int reltext : 1;
198 /* how many did we find? */
203 /* Alpha ELF linker hash table. */
205 struct alpha_elf_link_hash_table
207 struct elf_link_hash_table root;
209 /* The head of a list of .got subsections linked through
210 alpha_elf_tdata(abfd)->got_link_next. */
214 /* Look up an entry in a Alpha ELF linker hash table. */
216 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
217 ((struct alpha_elf_link_hash_entry *) \
218 elf_link_hash_lookup (&(table)->root, (string), (create), \
221 /* Traverse a Alpha ELF linker hash table. */
223 #define alpha_elf_link_hash_traverse(table, func, info) \
224 (elf_link_hash_traverse \
226 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
229 /* Get the Alpha ELF linker hash table from a link_info structure. */
231 #define alpha_elf_hash_table(p) \
232 ((struct alpha_elf_link_hash_table *) ((p)->hash))
234 /* Get the object's symbols as our own entry type. */
236 #define alpha_elf_sym_hashes(abfd) \
237 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
239 /* Should we do dynamic things to this symbol? */
242 alpha_elf_dynamic_symbol_p (h, info)
243 struct elf_link_hash_entry *h;
244 struct bfd_link_info *info;
249 while (h->root.type == bfd_link_hash_indirect
250 || h->root.type == bfd_link_hash_warning)
251 h = (struct elf_link_hash_entry *) h->root.u.i.link;
253 if (h->dynindx == -1)
256 if (h->root.type == bfd_link_hash_undefweak
257 || h->root.type == bfd_link_hash_defweak)
260 switch (ELF_ST_VISIBILITY (h->other))
268 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
273 if ((info->shared && !info->symbolic)
274 || ((h->elf_link_hash_flags
275 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
276 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
282 /* Create an entry in a Alpha ELF linker hash table. */
284 static struct bfd_hash_entry *
285 elf64_alpha_link_hash_newfunc (entry, table, string)
286 struct bfd_hash_entry *entry;
287 struct bfd_hash_table *table;
290 struct alpha_elf_link_hash_entry *ret =
291 (struct alpha_elf_link_hash_entry *) entry;
293 /* Allocate the structure if it has not already been allocated by a
295 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
296 ret = ((struct alpha_elf_link_hash_entry *)
297 bfd_hash_allocate (table,
298 sizeof (struct alpha_elf_link_hash_entry)));
299 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
300 return (struct bfd_hash_entry *) ret;
302 /* Call the allocation method of the superclass. */
303 ret = ((struct alpha_elf_link_hash_entry *)
304 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
306 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
308 /* Set local fields. */
309 memset (&ret->esym, 0, sizeof (EXTR));
310 /* We use -2 as a marker to indicate that the information has
311 not been set. -1 means there is no associated ifd. */
314 ret->got_entries = NULL;
315 ret->reloc_entries = NULL;
318 return (struct bfd_hash_entry *) ret;
321 /* Create a Alpha ELF linker hash table. */
323 static struct bfd_link_hash_table *
324 elf64_alpha_bfd_link_hash_table_create (abfd)
327 struct alpha_elf_link_hash_table *ret;
328 bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
330 ret = (struct alpha_elf_link_hash_table *) bfd_zalloc (abfd, amt);
331 if (ret == (struct alpha_elf_link_hash_table *) NULL)
334 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
335 elf64_alpha_link_hash_newfunc))
337 bfd_release (abfd, ret);
341 return &ret->root.root;
344 /* We have some private fields hanging off of the elf_tdata structure. */
346 struct alpha_elf_obj_tdata
348 struct elf_obj_tdata root;
350 /* For every input file, these are the got entries for that object's
352 struct alpha_elf_got_entry ** local_got_entries;
354 /* For every input file, this is the object that owns the got that
355 this input file uses. */
358 /* For every got, this is a linked list through the objects using this got */
359 bfd *in_got_link_next;
361 /* For every got, this is a link to the next got subsegment. */
364 /* For every got, this is the section. */
367 /* For every got, this is it's total number of *entries*. */
368 int total_got_entries;
370 /* For every got, this is the sum of the number of *entries* required
371 to hold all of the member object's local got. */
372 int n_local_got_entries;
375 #define alpha_elf_tdata(abfd) \
376 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
379 elf64_alpha_mkobject (abfd)
382 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
383 abfd->tdata.any = bfd_zalloc (abfd, amt);
384 if (abfd->tdata.any == NULL)
390 elf64_alpha_object_p (abfd)
393 /* Allocate our special target data. */
394 struct alpha_elf_obj_tdata *new_tdata;
395 bfd_size_type amt = sizeof (struct alpha_elf_obj_tdata);
396 new_tdata = bfd_zalloc (abfd, amt);
397 if (new_tdata == NULL)
399 new_tdata->root = *abfd->tdata.elf_obj_data;
400 abfd->tdata.any = new_tdata;
402 /* Set the right machine number for an Alpha ELF file. */
403 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
406 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
407 from smaller values. Start with zero, widen, *then* decrement. */
408 #define MINUS_ONE (((bfd_vma)0) - 1)
410 #define SKIP_HOWTO(N) \
411 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
413 static reloc_howto_type elf64_alpha_howto_table[] =
415 HOWTO (R_ALPHA_NONE, /* type */
417 0, /* size (0 = byte, 1 = short, 2 = long) */
419 true, /* pc_relative */
421 complain_overflow_dont, /* complain_on_overflow */
422 elf64_alpha_reloc_nil, /* special_function */
424 false, /* partial_inplace */
427 true), /* pcrel_offset */
429 /* A 32 bit reference to a symbol. */
430 HOWTO (R_ALPHA_REFLONG, /* type */
432 2, /* size (0 = byte, 1 = short, 2 = long) */
434 false, /* pc_relative */
436 complain_overflow_bitfield, /* complain_on_overflow */
437 0, /* special_function */
438 "REFLONG", /* name */
439 false, /* partial_inplace */
440 0xffffffff, /* src_mask */
441 0xffffffff, /* dst_mask */
442 false), /* pcrel_offset */
444 /* A 64 bit reference to a symbol. */
445 HOWTO (R_ALPHA_REFQUAD, /* type */
447 4, /* size (0 = byte, 1 = short, 2 = long) */
449 false, /* pc_relative */
451 complain_overflow_bitfield, /* complain_on_overflow */
452 0, /* special_function */
453 "REFQUAD", /* name */
454 false, /* partial_inplace */
455 MINUS_ONE, /* src_mask */
456 MINUS_ONE, /* dst_mask */
457 false), /* pcrel_offset */
459 /* A 32 bit GP relative offset. This is just like REFLONG except
460 that when the value is used the value of the gp register will be
462 HOWTO (R_ALPHA_GPREL32, /* type */
464 2, /* size (0 = byte, 1 = short, 2 = long) */
466 false, /* pc_relative */
468 complain_overflow_bitfield, /* complain_on_overflow */
469 0, /* special_function */
470 "GPREL32", /* name */
471 false, /* partial_inplace */
472 0xffffffff, /* src_mask */
473 0xffffffff, /* dst_mask */
474 false), /* pcrel_offset */
476 /* Used for an instruction that refers to memory off the GP register. */
477 HOWTO (R_ALPHA_LITERAL, /* type */
479 1, /* size (0 = byte, 1 = short, 2 = long) */
481 false, /* pc_relative */
483 complain_overflow_signed, /* complain_on_overflow */
484 0, /* special_function */
485 "ELF_LITERAL", /* name */
486 false, /* partial_inplace */
487 0xffff, /* src_mask */
488 0xffff, /* dst_mask */
489 false), /* pcrel_offset */
491 /* This reloc only appears immediately following an ELF_LITERAL reloc.
492 It identifies a use of the literal. The symbol index is special:
493 1 means the literal address is in the base register of a memory
494 format instruction; 2 means the literal address is in the byte
495 offset register of a byte-manipulation instruction; 3 means the
496 literal address is in the target register of a jsr instruction.
497 This does not actually do any relocation. */
498 HOWTO (R_ALPHA_LITUSE, /* type */
500 1, /* size (0 = byte, 1 = short, 2 = long) */
502 false, /* pc_relative */
504 complain_overflow_dont, /* complain_on_overflow */
505 elf64_alpha_reloc_nil, /* special_function */
507 false, /* partial_inplace */
510 false), /* pcrel_offset */
512 /* Load the gp register. This is always used for a ldah instruction
513 which loads the upper 16 bits of the gp register. The symbol
514 index of the GPDISP instruction is an offset in bytes to the lda
515 instruction that loads the lower 16 bits. The value to use for
516 the relocation is the difference between the GP value and the
517 current location; the load will always be done against a register
518 holding the current address.
520 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
521 any offset is present in the instructions, it is an offset from
522 the register to the ldah instruction. This lets us avoid any
523 stupid hackery like inventing a gp value to do partial relocation
524 against. Also unlike ECOFF, we do the whole relocation off of
525 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
526 space consuming bit, that, since all the information was present
527 in the GPDISP_HI16 reloc. */
528 HOWTO (R_ALPHA_GPDISP, /* type */
530 2, /* size (0 = byte, 1 = short, 2 = long) */
532 false, /* pc_relative */
534 complain_overflow_dont, /* complain_on_overflow */
535 elf64_alpha_reloc_gpdisp, /* special_function */
537 false, /* partial_inplace */
538 0xffff, /* src_mask */
539 0xffff, /* dst_mask */
540 true), /* pcrel_offset */
542 /* A 21 bit branch. */
543 HOWTO (R_ALPHA_BRADDR, /* type */
545 2, /* size (0 = byte, 1 = short, 2 = long) */
547 true, /* pc_relative */
549 complain_overflow_signed, /* complain_on_overflow */
550 0, /* special_function */
552 false, /* partial_inplace */
553 0x1fffff, /* src_mask */
554 0x1fffff, /* dst_mask */
555 true), /* pcrel_offset */
557 /* A hint for a jump to a register. */
558 HOWTO (R_ALPHA_HINT, /* type */
560 1, /* size (0 = byte, 1 = short, 2 = long) */
562 true, /* pc_relative */
564 complain_overflow_dont, /* complain_on_overflow */
565 0, /* special_function */
567 false, /* partial_inplace */
568 0x3fff, /* src_mask */
569 0x3fff, /* dst_mask */
570 true), /* pcrel_offset */
572 /* 16 bit PC relative offset. */
573 HOWTO (R_ALPHA_SREL16, /* type */
575 1, /* size (0 = byte, 1 = short, 2 = long) */
577 true, /* pc_relative */
579 complain_overflow_signed, /* complain_on_overflow */
580 0, /* special_function */
582 false, /* partial_inplace */
583 0xffff, /* src_mask */
584 0xffff, /* dst_mask */
585 true), /* pcrel_offset */
587 /* 32 bit PC relative offset. */
588 HOWTO (R_ALPHA_SREL32, /* type */
590 2, /* size (0 = byte, 1 = short, 2 = long) */
592 true, /* pc_relative */
594 complain_overflow_signed, /* complain_on_overflow */
595 0, /* special_function */
597 false, /* partial_inplace */
598 0xffffffff, /* src_mask */
599 0xffffffff, /* dst_mask */
600 true), /* pcrel_offset */
602 /* A 64 bit PC relative offset. */
603 HOWTO (R_ALPHA_SREL64, /* type */
605 4, /* size (0 = byte, 1 = short, 2 = long) */
607 true, /* pc_relative */
609 complain_overflow_signed, /* complain_on_overflow */
610 0, /* special_function */
612 false, /* partial_inplace */
613 MINUS_ONE, /* src_mask */
614 MINUS_ONE, /* dst_mask */
615 true), /* pcrel_offset */
617 /* Skip 12 - 16; deprecated ECOFF relocs. */
624 /* The high 16 bits of the displacement from GP to the target. */
625 HOWTO (R_ALPHA_GPRELHIGH,
627 1, /* size (0 = byte, 1 = short, 2 = long) */
629 false, /* pc_relative */
631 complain_overflow_signed, /* complain_on_overflow */
632 0, /* special_function */
633 "GPRELHIGH", /* name */
634 false, /* partial_inplace */
635 0xffff, /* src_mask */
636 0xffff, /* dst_mask */
637 false), /* pcrel_offset */
639 /* The low 16 bits of the displacement from GP to the target. */
640 HOWTO (R_ALPHA_GPRELLOW,
642 1, /* size (0 = byte, 1 = short, 2 = long) */
644 false, /* pc_relative */
646 complain_overflow_dont, /* complain_on_overflow */
647 0, /* special_function */
648 "GPRELLOW", /* name */
649 false, /* partial_inplace */
650 0xffff, /* src_mask */
651 0xffff, /* dst_mask */
652 false), /* pcrel_offset */
654 /* A 16-bit displacement from the GP to the target. */
655 HOWTO (R_ALPHA_GPREL16,
657 1, /* size (0 = byte, 1 = short, 2 = long) */
659 false, /* pc_relative */
661 complain_overflow_signed, /* complain_on_overflow */
662 0, /* special_function */
663 "GPREL16", /* name */
664 false, /* partial_inplace */
665 0xffff, /* src_mask */
666 0xffff, /* dst_mask */
667 false), /* pcrel_offset */
669 /* Skip 20 - 23; deprecated ECOFF relocs. */
675 /* Misc ELF relocations. */
677 /* A dynamic relocation to copy the target into our .dynbss section. */
678 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
679 is present because every other ELF has one, but should not be used
680 because .dynbss is an ugly thing. */
687 complain_overflow_dont,
688 bfd_elf_generic_reloc,
695 /* A dynamic relocation for a .got entry. */
696 HOWTO (R_ALPHA_GLOB_DAT,
702 complain_overflow_dont,
703 bfd_elf_generic_reloc,
710 /* A dynamic relocation for a .plt entry. */
711 HOWTO (R_ALPHA_JMP_SLOT,
717 complain_overflow_dont,
718 bfd_elf_generic_reloc,
725 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
726 HOWTO (R_ALPHA_RELATIVE,
732 complain_overflow_dont,
733 bfd_elf_generic_reloc,
740 /* A 21 bit branch that adjusts for gp loads. */
741 HOWTO (R_ALPHA_BRSGP, /* type */
743 2, /* size (0 = byte, 1 = short, 2 = long) */
745 true, /* pc_relative */
747 complain_overflow_signed, /* complain_on_overflow */
748 0, /* special_function */
750 false, /* partial_inplace */
751 0x1fffff, /* src_mask */
752 0x1fffff, /* dst_mask */
753 true), /* pcrel_offset */
756 /* A relocation function which doesn't do anything. */
758 static bfd_reloc_status_type
759 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
760 bfd *abfd ATTRIBUTE_UNUSED;
762 asymbol *sym ATTRIBUTE_UNUSED;
763 PTR data ATTRIBUTE_UNUSED;
766 char **error_message ATTRIBUTE_UNUSED;
769 reloc->address += sec->output_offset;
773 /* A relocation function used for an unsupported reloc. */
775 static bfd_reloc_status_type
776 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
777 bfd *abfd ATTRIBUTE_UNUSED;
779 asymbol *sym ATTRIBUTE_UNUSED;
780 PTR data ATTRIBUTE_UNUSED;
783 char **error_message ATTRIBUTE_UNUSED;
786 reloc->address += sec->output_offset;
787 return bfd_reloc_notsupported;
790 /* Do the work of the GPDISP relocation. */
792 static bfd_reloc_status_type
793 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
799 bfd_reloc_status_type ret = bfd_reloc_ok;
801 unsigned long i_ldah, i_lda;
803 i_ldah = bfd_get_32 (abfd, p_ldah);
804 i_lda = bfd_get_32 (abfd, p_lda);
806 /* Complain if the instructions are not correct. */
807 if (((i_ldah >> 26) & 0x3f) != 0x09
808 || ((i_lda >> 26) & 0x3f) != 0x08)
809 ret = bfd_reloc_dangerous;
811 /* Extract the user-supplied offset, mirroring the sign extensions
812 that the instructions perform. */
813 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
814 addend = (addend ^ 0x80008000) - 0x80008000;
818 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
819 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
820 ret = bfd_reloc_overflow;
822 /* compensate for the sign extension again. */
823 i_ldah = ((i_ldah & 0xffff0000)
824 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
825 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
827 bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
828 bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
833 /* The special function for the GPDISP reloc. */
835 static bfd_reloc_status_type
836 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
839 arelent *reloc_entry;
840 asymbol *sym ATTRIBUTE_UNUSED;
842 asection *input_section;
846 bfd_reloc_status_type ret;
847 bfd_vma gp, relocation;
848 bfd_byte *p_ldah, *p_lda;
850 /* Don't do anything if we're not doing a final link. */
853 reloc_entry->address += input_section->output_offset;
857 if (reloc_entry->address > input_section->_cooked_size ||
858 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
859 return bfd_reloc_outofrange;
861 /* The gp used in the portion of the output object to which this
862 input object belongs is cached on the input bfd. */
863 gp = _bfd_get_gp_value (abfd);
865 relocation = (input_section->output_section->vma
866 + input_section->output_offset
867 + reloc_entry->address);
869 p_ldah = (bfd_byte *) data + reloc_entry->address;
870 p_lda = p_ldah + reloc_entry->addend;
872 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
874 /* Complain if the instructions are not correct. */
875 if (ret == bfd_reloc_dangerous)
876 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
881 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
885 bfd_reloc_code_real_type bfd_reloc_val;
889 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
891 {BFD_RELOC_NONE, R_ALPHA_NONE},
892 {BFD_RELOC_32, R_ALPHA_REFLONG},
893 {BFD_RELOC_64, R_ALPHA_REFQUAD},
894 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
895 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
896 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
897 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
898 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
899 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
900 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
901 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
902 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
903 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
904 {BFD_RELOC_ALPHA_GPREL_HI16, R_ALPHA_GPRELHIGH},
905 {BFD_RELOC_ALPHA_GPREL_LO16, R_ALPHA_GPRELLOW},
906 {BFD_RELOC_GPREL16, R_ALPHA_GPREL16},
907 {BFD_RELOC_ALPHA_BRSGP, R_ALPHA_BRSGP},
910 /* Given a BFD reloc type, return a HOWTO structure. */
912 static reloc_howto_type *
913 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
914 bfd *abfd ATTRIBUTE_UNUSED;
915 bfd_reloc_code_real_type code;
917 const struct elf_reloc_map *i, *e;
918 i = e = elf64_alpha_reloc_map;
919 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
922 if (i->bfd_reloc_val == code)
923 return &elf64_alpha_howto_table[i->elf_reloc_val];
928 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
931 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
932 bfd *abfd ATTRIBUTE_UNUSED;
934 Elf64_Internal_Rela *dst;
938 r_type = ELF64_R_TYPE(dst->r_info);
939 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
940 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
943 /* These functions do relaxation for Alpha ELF.
945 Currently I'm only handling what I can do with existing compiler
946 and assembler support, which means no instructions are removed,
947 though some may be nopped. At this time GCC does not emit enough
948 information to do all of the relaxing that is possible. It will
949 take some not small amount of work for that to happen.
951 There are a couple of interesting papers that I once read on this
952 subject, that I cannot find references to at the moment, that
953 related to Alpha in particular. They are by David Wall, then of
958 #define INSN_JSR 0x68004000
959 #define INSN_JSR_MASK 0xfc00c000
963 #define INSN_UNOP 0x2ffe0000
965 struct alpha_relax_info
970 Elf_Internal_Rela *relocs, *relend;
971 struct bfd_link_info *link_info;
972 boolean changed_contents;
973 boolean changed_relocs;
977 struct alpha_elf_link_hash_entry *h;
978 struct alpha_elf_got_entry *gotent;
982 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
983 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
984 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
986 static boolean elf64_alpha_relax_without_lituse
987 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
988 Elf_Internal_Rela *irel));
990 static bfd_vma elf64_alpha_relax_opt_call
991 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
993 static boolean elf64_alpha_relax_section
994 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
997 static Elf_Internal_Rela *
998 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
999 Elf_Internal_Rela *rel, *relend;
1003 while (rel < relend)
1005 if (rel->r_offset == offset
1006 && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
1013 static Elf_Internal_Rela *
1014 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1015 struct alpha_relax_info *info;
1017 Elf_Internal_Rela *irel, *irelend;
1019 Elf_Internal_Rela *urel;
1020 int flags, count, i;
1021 bfd_signed_vma disp;
1024 boolean lit_reused = false;
1025 boolean all_optimized = true;
1026 unsigned int lit_insn;
1028 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1029 if (lit_insn >> 26 != OP_LDQ)
1031 ((*_bfd_error_handler)
1032 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1033 bfd_archive_filename (info->abfd), info->sec->name,
1034 (unsigned long) irel->r_offset));
1038 /* Summarize how this particular LITERAL is used. */
1039 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1041 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1043 if (urel->r_addend <= 3)
1044 flags |= 1 << urel->r_addend;
1047 /* A little preparation for the loop... */
1048 disp = symval - info->gp;
1050 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1054 bfd_signed_vma xdisp;
1056 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1058 switch (urel->r_addend)
1060 default: /* 0 = ADDRESS FORMAT */
1061 /* This type is really just a placeholder to note that all
1062 uses cannot be optimized, but to still allow some. */
1063 all_optimized = false;
1066 case 1: /* MEM FORMAT */
1067 /* We can always optimize 16-bit displacements. */
1069 /* Extract the displacement from the instruction, sign-extending
1070 it if necessary, then test whether it is within 16 or 32 bits
1071 displacement from GP. */
1072 insn_disp = insn & 0x0000ffff;
1073 if (insn_disp & 0x00008000)
1074 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1076 xdisp = disp + insn_disp;
1077 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1078 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1082 /* Take the op code and dest from this insn, take the base
1083 register from the literal insn. Leave the offset alone. */
1084 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1085 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1087 urel->r_addend = irel->r_addend;
1088 info->changed_relocs = true;
1090 bfd_put_32 (info->abfd, (bfd_vma) insn,
1091 info->contents + urel->r_offset);
1092 info->changed_contents = true;
1095 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1096 else if (fits32 && !(flags & ~6))
1098 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1100 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1102 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1103 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1104 info->contents + irel->r_offset);
1106 info->changed_contents = true;
1108 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1110 urel->r_addend = irel->r_addend;
1111 info->changed_relocs = true;
1114 all_optimized = false;
1117 case 2: /* BYTE OFFSET FORMAT */
1118 /* We can always optimize byte instructions. */
1120 /* FIXME: sanity check the insn for byte op. Check that the
1121 literal dest reg is indeed Rb in the byte insn. */
1123 insn &= ~ (unsigned) 0x001ff000;
1124 insn |= ((symval & 7) << 13) | 0x1000;
1126 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1128 info->changed_relocs = true;
1130 bfd_put_32 (info->abfd, (bfd_vma) insn,
1131 info->contents + urel->r_offset);
1132 info->changed_contents = true;
1135 case 3: /* CALL FORMAT */
1137 /* If not zero, place to jump without needing pv. */
1138 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1139 bfd_vma org = (info->sec->output_section->vma
1140 + info->sec->output_offset
1141 + urel->r_offset + 4);
1142 bfd_signed_vma odisp;
1144 odisp = (optdest ? optdest : symval) - org;
1145 if (odisp >= -0x400000 && odisp < 0x400000)
1147 Elf_Internal_Rela *xrel;
1149 /* Preserve branch prediction call stack when possible. */
1150 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1151 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1153 insn = (OP_BR << 26) | (insn & 0x03e00000);
1155 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1157 urel->r_addend = irel->r_addend;
1160 urel->r_addend += optdest - symval;
1162 all_optimized = false;
1164 bfd_put_32 (info->abfd, (bfd_vma) insn,
1165 info->contents + urel->r_offset);
1167 /* Kill any HINT reloc that might exist for this insn. */
1168 xrel = (elf64_alpha_find_reloc_at_ofs
1169 (info->relocs, info->relend, urel->r_offset,
1172 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1174 info->changed_contents = true;
1175 info->changed_relocs = true;
1178 all_optimized = false;
1180 /* Even if the target is not in range for a direct branch,
1181 if we share a GP, we can eliminate the gp reload. */
1184 Elf_Internal_Rela *gpdisp
1185 = (elf64_alpha_find_reloc_at_ofs
1186 (irel, irelend, urel->r_offset + 4, R_ALPHA_GPDISP));
1189 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1190 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1191 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1192 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1194 /* Verify that the instruction is "ldah $29,0($26)".
1195 Consider a function that ends in a noreturn call,
1196 and that the next function begins with an ldgp,
1197 and that by accident there is no padding between.
1198 In that case the insn would use $27 as the base. */
1199 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1201 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1202 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1204 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1205 info->changed_contents = true;
1206 info->changed_relocs = true;
1215 /* If all cases were optimized, we can reduce the use count on this
1216 got entry by one, possibly eliminating it. */
1219 info->gotent->use_count -= 1;
1220 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1222 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1224 /* If the literal instruction is no longer needed (it may have been
1225 reused. We can eliminate it.
1226 ??? For now, I don't want to deal with compacting the section,
1227 so just nop it out. */
1230 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1231 info->changed_relocs = true;
1233 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1234 info->contents + irel->r_offset);
1235 info->changed_contents = true;
1239 return irel + count;
1243 elf64_alpha_relax_opt_call (info, symval)
1244 struct alpha_relax_info *info;
1247 /* If the function has the same gp, and we can identify that the
1248 function does not use its function pointer, we can eliminate the
1251 /* If the symbol is marked NOPV, we are being told the function never
1252 needs its procedure value. */
1253 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1256 /* If the symbol is marked STD_GP, we are being told the function does
1257 a normal ldgp in the first two words. */
1258 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1261 /* Otherwise, we may be able to identify a GP load in the first two
1262 words, which we can then skip. */
1265 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1268 /* Load the relocations from the section that the target symbol is in. */
1269 if (info->sec == info->tsec)
1271 tsec_relocs = info->relocs;
1272 tsec_relend = info->relend;
1277 tsec_relocs = (_bfd_elf64_link_read_relocs
1278 (info->abfd, info->tsec, (PTR) NULL,
1279 (Elf_Internal_Rela *) NULL,
1280 info->link_info->keep_memory));
1281 if (tsec_relocs == NULL)
1283 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1284 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1287 /* Recover the symbol's offset within the section. */
1288 ofs = (symval - info->tsec->output_section->vma
1289 - info->tsec->output_offset);
1291 /* Look for a GPDISP reloc. */
1292 gpdisp = (elf64_alpha_find_reloc_at_ofs
1293 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1295 if (!gpdisp || gpdisp->r_addend != 4)
1305 /* We've now determined that we can skip an initial gp load. Verify
1306 that the call and the target use the same gp. */
1307 if (info->link_info->hash->creator != info->tsec->owner->xvec
1308 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1315 elf64_alpha_relax_without_lituse (info, symval, irel)
1316 struct alpha_relax_info *info;
1318 Elf_Internal_Rela *irel;
1321 bfd_signed_vma disp;
1323 /* Get the instruction. */
1324 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1326 if (insn >> 26 != OP_LDQ)
1328 ((*_bfd_error_handler)
1329 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1330 bfd_archive_filename (info->abfd), info->sec->name,
1331 (unsigned long) irel->r_offset));
1335 /* So we aren't told much. Do what we can with the address load and
1336 fake the rest. All of the optimizations here require that the
1337 offset from the GP fit in 16 bits. */
1339 disp = symval - info->gp;
1340 if (disp < -0x8000 || disp >= 0x8000)
1343 /* On the LITERAL instruction itself, consider exchanging
1344 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1346 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1347 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1348 info->changed_contents = true;
1350 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPREL16);
1351 info->changed_relocs = true;
1353 /* Reduce the use count on this got entry by one, possibly
1355 info->gotent->use_count -= 1;
1356 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1358 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1360 /* ??? Search forward through this basic block looking for insns
1361 that use the target register. Stop after an insn modifying the
1362 register is seen, or after a branch or call.
1364 Any such memory load insn may be substituted by a load directly
1365 off the GP. This allows the memory load insn to be issued before
1366 the calculated GP register would otherwise be ready.
1368 Any such jsr insn can be replaced by a bsr if it is in range.
1370 This would mean that we'd have to _add_ relocations, the pain of
1371 which gives one pause. */
1377 elf64_alpha_relax_section (abfd, sec, link_info, again)
1380 struct bfd_link_info *link_info;
1383 Elf_Internal_Shdr *symtab_hdr;
1384 Elf_Internal_Shdr *shndx_hdr;
1385 Elf_Internal_Rela *internal_relocs;
1386 Elf_Internal_Rela *free_relocs = NULL;
1387 Elf_Internal_Rela *irel, *irelend;
1388 bfd_byte *free_contents = NULL;
1389 Elf64_External_Sym *extsyms = NULL;
1390 Elf64_External_Sym *free_extsyms = NULL;
1391 Elf_External_Sym_Shndx *shndx_buf = NULL;
1392 struct alpha_elf_got_entry **local_got_entries;
1393 struct alpha_relax_info info;
1395 /* We are not currently changing any sizes, so only one pass. */
1398 if (link_info->relocateable
1399 || (sec->flags & SEC_RELOC) == 0
1400 || sec->reloc_count == 0)
1403 /* If this is the first time we have been called for this section,
1404 initialize the cooked size. */
1405 if (sec->_cooked_size == 0)
1406 sec->_cooked_size = sec->_raw_size;
1408 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1409 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1411 /* Load the relocations for this section. */
1412 internal_relocs = (_bfd_elf64_link_read_relocs
1413 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1414 link_info->keep_memory));
1415 if (internal_relocs == NULL)
1417 if (! link_info->keep_memory)
1418 free_relocs = internal_relocs;
1420 memset(&info, 0, sizeof (info));
1423 info.link_info = link_info;
1424 info.relocs = internal_relocs;
1425 info.relend = irelend = internal_relocs + sec->reloc_count;
1427 /* Find the GP for this object. */
1428 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1431 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1432 info.gp = _bfd_get_gp_value (info.gotobj);
1435 info.gp = (sgot->output_section->vma
1436 + sgot->output_offset
1438 _bfd_set_gp_value (info.gotobj, info.gp);
1442 for (irel = internal_relocs; irel < irelend; irel++)
1445 Elf_Internal_Sym isym;
1446 struct alpha_elf_got_entry *gotent;
1448 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1451 /* Get the section contents. */
1452 if (info.contents == NULL)
1454 if (elf_section_data (sec)->this_hdr.contents != NULL)
1455 info.contents = elf_section_data (sec)->this_hdr.contents;
1458 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1459 if (info.contents == NULL)
1461 free_contents = info.contents;
1463 if (! bfd_get_section_contents (abfd, sec, info.contents,
1464 (file_ptr) 0, sec->_raw_size))
1469 /* Read this BFD's symbols if we haven't done so already. */
1470 if (extsyms == NULL)
1474 if (symtab_hdr->contents != NULL)
1475 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1478 amt = symtab_hdr->sh_info;
1479 amt *= sizeof (Elf64_External_Sym);
1480 extsyms = (Elf64_External_Sym *) bfd_malloc (amt);
1481 if (extsyms == NULL)
1483 free_extsyms = extsyms;
1484 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1485 || bfd_bread ((PTR) extsyms, amt, abfd) != amt)
1489 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1490 if (shndx_hdr->sh_size != 0)
1492 amt = symtab_hdr->sh_info;
1493 amt *= sizeof (Elf_External_Sym_Shndx);
1494 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1495 if (shndx_buf == NULL)
1497 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1498 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1503 /* Get the value of the symbol referred to by the reloc. */
1504 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1506 /* A local symbol. */
1507 Elf64_External_Sym *esym;
1508 Elf_External_Sym_Shndx *shndx;
1510 esym = extsyms + ELF64_R_SYM (irel->r_info);
1511 shndx = shndx_buf + (shndx_buf ? ELF64_R_SYM (irel->r_info) : 0);
1512 bfd_elf64_swap_symbol_in (abfd, esym, shndx, &isym);
1513 if (isym.st_shndx == SHN_UNDEF)
1514 info.tsec = bfd_und_section_ptr;
1515 else if (isym.st_shndx == SHN_ABS)
1516 info.tsec = bfd_abs_section_ptr;
1517 else if (isym.st_shndx == SHN_COMMON)
1518 info.tsec = bfd_com_section_ptr;
1520 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1523 info.other = isym.st_other;
1524 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1525 symval = isym.st_value;
1530 struct alpha_elf_link_hash_entry *h;
1532 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1533 h = alpha_elf_sym_hashes (abfd)[indx];
1534 BFD_ASSERT (h != NULL);
1536 while (h->root.root.type == bfd_link_hash_indirect
1537 || h->root.root.type == bfd_link_hash_warning)
1538 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1540 /* We can't do anthing with undefined or dynamic symbols. */
1541 if (h->root.root.type == bfd_link_hash_undefined
1542 || h->root.root.type == bfd_link_hash_undefweak
1543 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1547 info.tsec = h->root.root.u.def.section;
1548 info.other = h->root.other;
1549 gotent = h->got_entries;
1550 symval = h->root.root.u.def.value;
1553 /* Search for the got entry to be used by this relocation. */
1554 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1555 gotent = gotent->next;
1556 info.gotent = gotent;
1558 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1559 symval += irel->r_addend;
1561 BFD_ASSERT(info.gotent != NULL);
1563 /* If there exist LITUSE relocations immediately following, this
1564 opens up all sorts of interesting optimizations, because we
1565 now know every location that this address load is used. */
1567 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1569 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1575 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1580 if (!elf64_alpha_size_got_sections (abfd, link_info))
1583 if (info.changed_relocs)
1585 elf_section_data (sec)->relocs = internal_relocs;
1587 else if (free_relocs != NULL)
1592 if (info.changed_contents)
1594 elf_section_data (sec)->this_hdr.contents = info.contents;
1596 else if (free_contents != NULL)
1598 if (! link_info->keep_memory)
1599 free (free_contents);
1602 /* Cache the section contents for elf_link_input_bfd. */
1603 elf_section_data (sec)->this_hdr.contents = info.contents;
1607 if (shndx_buf != NULL)
1610 if (free_extsyms != NULL)
1612 if (! link_info->keep_memory)
1613 free (free_extsyms);
1616 /* Cache the symbols for elf_link_input_bfd. */
1617 symtab_hdr->contents = (unsigned char *) extsyms;
1621 *again = info.changed_contents || info.changed_relocs;
1626 if (free_relocs != NULL)
1628 if (free_contents != NULL)
1629 free (free_contents);
1630 if (shndx_buf != NULL)
1632 if (free_extsyms != NULL)
1633 free (free_extsyms);
1638 #define PLT_HEADER_SIZE 32
1639 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1640 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1641 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1642 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
1644 #define PLT_ENTRY_SIZE 12
1645 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1646 #define PLT_ENTRY_WORD2 0
1647 #define PLT_ENTRY_WORD3 0
1649 #define MAX_GOT_ENTRIES (64*1024 / 8)
1651 #ifndef ELF_DYNAMIC_INTERPRETER
1652 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1655 /* Handle an Alpha specific section when reading an object file. This
1656 is called when elfcode.h finds a section with an unknown type.
1657 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1661 elf64_alpha_section_from_shdr (abfd, hdr, name)
1663 Elf64_Internal_Shdr *hdr;
1668 /* There ought to be a place to keep ELF backend specific flags, but
1669 at the moment there isn't one. We just keep track of the
1670 sections by their name, instead. Fortunately, the ABI gives
1671 suggested names for all the MIPS specific sections, so we will
1672 probably get away with this. */
1673 switch (hdr->sh_type)
1675 case SHT_ALPHA_DEBUG:
1676 if (strcmp (name, ".mdebug") != 0)
1683 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1685 newsect = hdr->bfd_section;
1687 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1689 if (! bfd_set_section_flags (abfd, newsect,
1690 (bfd_get_section_flags (abfd, newsect)
1698 /* Convert Alpha specific section flags to bfd internal section flags. */
1701 elf64_alpha_section_flags (flags, hdr)
1703 Elf64_Internal_Shdr *hdr;
1705 if (hdr->sh_flags & SHF_ALPHA_GPREL)
1706 *flags |= SEC_SMALL_DATA;
1711 /* Set the correct type for an Alpha ELF section. We do this by the
1712 section name, which is a hack, but ought to work. */
1715 elf64_alpha_fake_sections (abfd, hdr, sec)
1717 Elf64_Internal_Shdr *hdr;
1720 register const char *name;
1722 name = bfd_get_section_name (abfd, sec);
1724 if (strcmp (name, ".mdebug") == 0)
1726 hdr->sh_type = SHT_ALPHA_DEBUG;
1727 /* In a shared object on Irix 5.3, the .mdebug section has an
1728 entsize of 0. FIXME: Does this matter? */
1729 if ((abfd->flags & DYNAMIC) != 0 )
1730 hdr->sh_entsize = 0;
1732 hdr->sh_entsize = 1;
1734 else if ((sec->flags & SEC_SMALL_DATA)
1735 || strcmp (name, ".sdata") == 0
1736 || strcmp (name, ".sbss") == 0
1737 || strcmp (name, ".lit4") == 0
1738 || strcmp (name, ".lit8") == 0)
1739 hdr->sh_flags |= SHF_ALPHA_GPREL;
1744 /* Hook called by the linker routine which adds symbols from an object
1745 file. We use it to put .comm items in .sbss, and not .bss. */
1748 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1750 struct bfd_link_info *info;
1751 const Elf_Internal_Sym *sym;
1752 const char **namep ATTRIBUTE_UNUSED;
1753 flagword *flagsp ATTRIBUTE_UNUSED;
1757 if (sym->st_shndx == SHN_COMMON
1758 && !info->relocateable
1759 && sym->st_size <= elf_gp_size (abfd))
1761 /* Common symbols less than or equal to -G nn bytes are
1762 automatically put into .sbss. */
1764 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1768 scomm = bfd_make_section (abfd, ".scommon");
1770 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1772 | SEC_LINKER_CREATED)))
1777 *valp = sym->st_size;
1783 /* Create the .got section. */
1786 elf64_alpha_create_got_section(abfd, info)
1788 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1792 if (bfd_get_section_by_name (abfd, ".got"))
1795 s = bfd_make_section (abfd, ".got");
1797 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1800 | SEC_LINKER_CREATED))
1801 || !bfd_set_section_alignment (abfd, s, 3))
1804 alpha_elf_tdata (abfd)->got = s;
1809 /* Create all the dynamic sections. */
1812 elf64_alpha_create_dynamic_sections (abfd, info)
1814 struct bfd_link_info *info;
1817 struct elf_link_hash_entry *h;
1819 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1821 s = bfd_make_section (abfd, ".plt");
1823 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1826 | SEC_LINKER_CREATED
1828 || ! bfd_set_section_alignment (abfd, s, 3))
1831 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1834 if (! (_bfd_generic_link_add_one_symbol
1835 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1836 (bfd_vma) 0, (const char *) NULL, false,
1837 get_elf_backend_data (abfd)->collect,
1838 (struct bfd_link_hash_entry **) &h)))
1840 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1841 h->type = STT_OBJECT;
1844 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1847 s = bfd_make_section (abfd, ".rela.plt");
1849 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1852 | SEC_LINKER_CREATED
1854 || ! bfd_set_section_alignment (abfd, s, 3))
1857 /* We may or may not have created a .got section for this object, but
1858 we definitely havn't done the rest of the work. */
1860 if (!elf64_alpha_create_got_section (abfd, info))
1863 s = bfd_make_section(abfd, ".rela.got");
1865 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1868 | SEC_LINKER_CREATED
1870 || !bfd_set_section_alignment (abfd, s, 3))
1873 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1874 dynobj's .got section. We don't do this in the linker script
1875 because we don't want to define the symbol if we are not creating
1876 a global offset table. */
1878 if (!(_bfd_generic_link_add_one_symbol
1879 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1880 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1881 false, get_elf_backend_data (abfd)->collect,
1882 (struct bfd_link_hash_entry **) &h)))
1884 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1885 h->type = STT_OBJECT;
1888 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1891 elf_hash_table (info)->hgot = h;
1896 /* Read ECOFF debugging information from a .mdebug section into a
1897 ecoff_debug_info structure. */
1900 elf64_alpha_read_ecoff_info (abfd, section, debug)
1903 struct ecoff_debug_info *debug;
1906 const struct ecoff_debug_swap *swap;
1907 char *ext_hdr = NULL;
1909 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1910 memset (debug, 0, sizeof (*debug));
1912 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1913 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1916 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1917 swap->external_hdr_size)
1921 symhdr = &debug->symbolic_header;
1922 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1924 /* The symbolic header contains absolute file offsets and sizes to
1926 #define READ(ptr, offset, count, size, type) \
1927 if (symhdr->count == 0) \
1928 debug->ptr = NULL; \
1931 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
1932 debug->ptr = (type) bfd_malloc (amt); \
1933 if (debug->ptr == NULL) \
1934 goto error_return; \
1935 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1936 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1937 goto error_return; \
1940 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1941 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1942 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1943 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1944 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
1945 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1947 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1948 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1949 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
1950 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
1951 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
1955 debug->adjust = NULL;
1960 if (ext_hdr != NULL)
1962 if (debug->line != NULL)
1964 if (debug->external_dnr != NULL)
1965 free (debug->external_dnr);
1966 if (debug->external_pdr != NULL)
1967 free (debug->external_pdr);
1968 if (debug->external_sym != NULL)
1969 free (debug->external_sym);
1970 if (debug->external_opt != NULL)
1971 free (debug->external_opt);
1972 if (debug->external_aux != NULL)
1973 free (debug->external_aux);
1974 if (debug->ss != NULL)
1976 if (debug->ssext != NULL)
1977 free (debug->ssext);
1978 if (debug->external_fdr != NULL)
1979 free (debug->external_fdr);
1980 if (debug->external_rfd != NULL)
1981 free (debug->external_rfd);
1982 if (debug->external_ext != NULL)
1983 free (debug->external_ext);
1987 /* Alpha ELF local labels start with '$'. */
1990 elf64_alpha_is_local_label_name (abfd, name)
1991 bfd *abfd ATTRIBUTE_UNUSED;
1994 return name[0] == '$';
1997 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1998 routine in order to handle the ECOFF debugging information. We
1999 still call this mips_elf_find_line because of the slot
2000 find_line_info in elf_obj_tdata is declared that way. */
2002 struct mips_elf_find_line
2004 struct ecoff_debug_info d;
2005 struct ecoff_find_line i;
2009 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2010 functionname_ptr, line_ptr)
2015 const char **filename_ptr;
2016 const char **functionname_ptr;
2017 unsigned int *line_ptr;
2021 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2022 filename_ptr, functionname_ptr,
2024 &elf_tdata (abfd)->dwarf2_find_line_info))
2027 msec = bfd_get_section_by_name (abfd, ".mdebug");
2031 struct mips_elf_find_line *fi;
2032 const struct ecoff_debug_swap * const swap =
2033 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2035 /* If we are called during a link, alpha_elf_final_link may have
2036 cleared the SEC_HAS_CONTENTS field. We force it back on here
2037 if appropriate (which it normally will be). */
2038 origflags = msec->flags;
2039 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2040 msec->flags |= SEC_HAS_CONTENTS;
2042 fi = elf_tdata (abfd)->find_line_info;
2045 bfd_size_type external_fdr_size;
2048 struct fdr *fdr_ptr;
2049 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2051 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2054 msec->flags = origflags;
2058 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2060 msec->flags = origflags;
2064 /* Swap in the FDR information. */
2065 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2066 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2067 if (fi->d.fdr == NULL)
2069 msec->flags = origflags;
2072 external_fdr_size = swap->external_fdr_size;
2073 fdr_ptr = fi->d.fdr;
2074 fraw_src = (char *) fi->d.external_fdr;
2075 fraw_end = (fraw_src
2076 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2077 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2078 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2080 elf_tdata (abfd)->find_line_info = fi;
2082 /* Note that we don't bother to ever free this information.
2083 find_nearest_line is either called all the time, as in
2084 objdump -l, so the information should be saved, or it is
2085 rarely called, as in ld error messages, so the memory
2086 wasted is unimportant. Still, it would probably be a
2087 good idea for free_cached_info to throw it away. */
2090 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2091 &fi->i, filename_ptr, functionname_ptr,
2094 msec->flags = origflags;
2098 msec->flags = origflags;
2101 /* Fall back on the generic ELF find_nearest_line routine. */
2103 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2104 filename_ptr, functionname_ptr,
2108 /* Structure used to pass information to alpha_elf_output_extsym. */
2113 struct bfd_link_info *info;
2114 struct ecoff_debug_info *debug;
2115 const struct ecoff_debug_swap *swap;
2120 elf64_alpha_output_extsym (h, data)
2121 struct alpha_elf_link_hash_entry *h;
2124 struct extsym_info *einfo = (struct extsym_info *) data;
2126 asection *sec, *output_section;
2128 if (h->root.root.type == bfd_link_hash_warning)
2129 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2131 if (h->root.indx == -2)
2133 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2134 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2135 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2136 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2138 else if (einfo->info->strip == strip_all
2139 || (einfo->info->strip == strip_some
2140 && bfd_hash_lookup (einfo->info->keep_hash,
2141 h->root.root.root.string,
2142 false, false) == NULL))
2150 if (h->esym.ifd == -2)
2153 h->esym.cobol_main = 0;
2154 h->esym.weakext = 0;
2155 h->esym.reserved = 0;
2156 h->esym.ifd = ifdNil;
2157 h->esym.asym.value = 0;
2158 h->esym.asym.st = stGlobal;
2160 if (h->root.root.type != bfd_link_hash_defined
2161 && h->root.root.type != bfd_link_hash_defweak)
2162 h->esym.asym.sc = scAbs;
2167 sec = h->root.root.u.def.section;
2168 output_section = sec->output_section;
2170 /* When making a shared library and symbol h is the one from
2171 the another shared library, OUTPUT_SECTION may be null. */
2172 if (output_section == NULL)
2173 h->esym.asym.sc = scUndefined;
2176 name = bfd_section_name (output_section->owner, output_section);
2178 if (strcmp (name, ".text") == 0)
2179 h->esym.asym.sc = scText;
2180 else if (strcmp (name, ".data") == 0)
2181 h->esym.asym.sc = scData;
2182 else if (strcmp (name, ".sdata") == 0)
2183 h->esym.asym.sc = scSData;
2184 else if (strcmp (name, ".rodata") == 0
2185 || strcmp (name, ".rdata") == 0)
2186 h->esym.asym.sc = scRData;
2187 else if (strcmp (name, ".bss") == 0)
2188 h->esym.asym.sc = scBss;
2189 else if (strcmp (name, ".sbss") == 0)
2190 h->esym.asym.sc = scSBss;
2191 else if (strcmp (name, ".init") == 0)
2192 h->esym.asym.sc = scInit;
2193 else if (strcmp (name, ".fini") == 0)
2194 h->esym.asym.sc = scFini;
2196 h->esym.asym.sc = scAbs;
2200 h->esym.asym.reserved = 0;
2201 h->esym.asym.index = indexNil;
2204 if (h->root.root.type == bfd_link_hash_common)
2205 h->esym.asym.value = h->root.root.u.c.size;
2206 else if (h->root.root.type == bfd_link_hash_defined
2207 || h->root.root.type == bfd_link_hash_defweak)
2209 if (h->esym.asym.sc == scCommon)
2210 h->esym.asym.sc = scBss;
2211 else if (h->esym.asym.sc == scSCommon)
2212 h->esym.asym.sc = scSBss;
2214 sec = h->root.root.u.def.section;
2215 output_section = sec->output_section;
2216 if (output_section != NULL)
2217 h->esym.asym.value = (h->root.root.u.def.value
2218 + sec->output_offset
2219 + output_section->vma);
2221 h->esym.asym.value = 0;
2223 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2225 /* Set type and value for a symbol with a function stub. */
2226 h->esym.asym.st = stProc;
2227 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2229 h->esym.asym.value = 0;
2232 output_section = sec->output_section;
2233 if (output_section != NULL)
2234 h->esym.asym.value = (h->root.plt.offset
2235 + sec->output_offset
2236 + output_section->vma);
2238 h->esym.asym.value = 0;
2242 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2243 h->root.root.root.string,
2246 einfo->failed = true;
2253 /* FIXME: Create a runtime procedure table from the .mdebug section.
2256 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2259 struct bfd_link_info *info;
2261 struct ecoff_debug_info *debug;
2264 /* Handle dynamic relocations when doing an Alpha ELF link. */
2267 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2269 struct bfd_link_info *info;
2271 const Elf_Internal_Rela *relocs;
2275 const char *rel_sec_name;
2276 Elf_Internal_Shdr *symtab_hdr;
2277 struct alpha_elf_link_hash_entry **sym_hashes;
2278 struct alpha_elf_got_entry **local_got_entries;
2279 const Elf_Internal_Rela *rel, *relend;
2283 if (info->relocateable)
2286 dynobj = elf_hash_table(info)->dynobj;
2288 elf_hash_table(info)->dynobj = dynobj = abfd;
2291 rel_sec_name = NULL;
2292 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2293 sym_hashes = alpha_elf_sym_hashes(abfd);
2294 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2297 relend = relocs + sec->reloc_count;
2298 for (rel = relocs; rel < relend; ++rel)
2300 unsigned long r_symndx, r_type;
2301 struct alpha_elf_link_hash_entry *h;
2303 r_symndx = ELF64_R_SYM (rel->r_info);
2304 if (r_symndx < symtab_hdr->sh_info)
2308 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2310 while (h->root.root.type == bfd_link_hash_indirect
2311 || h->root.root.type == bfd_link_hash_warning)
2312 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2314 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2316 r_type = ELF64_R_TYPE (rel->r_info);
2320 case R_ALPHA_LITERAL:
2322 struct alpha_elf_got_entry *gotent;
2327 /* Search for and possibly create a got entry. */
2328 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2329 if (gotent->gotobj == abfd &&
2330 gotent->addend == rel->r_addend)
2335 amt = sizeof (struct alpha_elf_got_entry);
2336 gotent = ((struct alpha_elf_got_entry *)
2337 bfd_alloc (abfd, amt));
2341 gotent->gotobj = abfd;
2342 gotent->addend = rel->r_addend;
2343 gotent->got_offset = -1;
2345 gotent->use_count = 1;
2347 gotent->next = h->got_entries;
2348 h->got_entries = gotent;
2350 alpha_elf_tdata (abfd)->total_got_entries++;
2353 gotent->use_count += 1;
2357 /* This is a local .got entry -- record for merge. */
2358 if (!local_got_entries)
2361 size = symtab_hdr->sh_info;
2362 size *= sizeof (struct alpha_elf_got_entry *);
2364 local_got_entries = ((struct alpha_elf_got_entry **)
2365 bfd_alloc (abfd, size));
2366 if (!local_got_entries)
2369 memset (local_got_entries, 0, (size_t) size);
2370 alpha_elf_tdata (abfd)->local_got_entries =
2374 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2375 gotent != NULL && gotent->addend != rel->r_addend;
2376 gotent = gotent->next)
2380 amt = sizeof (struct alpha_elf_got_entry);
2381 gotent = ((struct alpha_elf_got_entry *)
2382 bfd_alloc (abfd, amt));
2386 gotent->gotobj = abfd;
2387 gotent->addend = rel->r_addend;
2388 gotent->got_offset = -1;
2390 gotent->use_count = 1;
2392 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2393 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2395 alpha_elf_tdata(abfd)->total_got_entries++;
2396 alpha_elf_tdata(abfd)->n_local_got_entries++;
2399 gotent->use_count += 1;
2402 /* Remember how this literal is used from its LITUSEs.
2403 This will be important when it comes to decide if we can
2404 create a .plt entry for a function symbol. */
2406 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2411 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2412 flags |= 1 << rel->r_addend;
2414 while (rel+1 < relend &&
2415 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2419 /* No LITUSEs -- presumably the address is not being
2420 loaded for nothing. */
2421 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2424 gotent->flags |= flags;
2427 /* Make a guess as to whether a .plt entry will be needed. */
2428 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2429 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2431 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2436 case R_ALPHA_GPDISP:
2437 case R_ALPHA_GPREL16:
2438 case R_ALPHA_GPREL32:
2439 case R_ALPHA_GPRELHIGH:
2440 case R_ALPHA_GPRELLOW:
2442 /* We don't actually use the .got here, but the sections must
2443 be created before the linker maps input sections to output
2447 if (!elf64_alpha_create_got_section (abfd, info))
2450 /* Make sure the object's gotobj is set to itself so
2451 that we default to every object with its own .got.
2452 We'll merge .gots later once we've collected each
2454 alpha_elf_tdata(abfd)->gotobj = abfd;
2460 case R_ALPHA_SREL16:
2461 case R_ALPHA_SREL32:
2462 case R_ALPHA_SREL64:
2467 case R_ALPHA_REFLONG:
2468 case R_ALPHA_REFQUAD:
2469 if (rel_sec_name == NULL)
2471 rel_sec_name = (bfd_elf_string_from_elf_section
2472 (abfd, elf_elfheader(abfd)->e_shstrndx,
2473 elf_section_data(sec)->rel_hdr.sh_name));
2474 if (rel_sec_name == NULL)
2477 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2478 && strcmp (bfd_get_section_name (abfd, sec),
2479 rel_sec_name+5) == 0);
2482 /* We need to create the section here now whether we eventually
2483 use it or not so that it gets mapped to an output section by
2484 the linker. If not used, we'll kill it in
2485 size_dynamic_sections. */
2488 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2493 sreloc = bfd_make_section (dynobj, rel_sec_name);
2494 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
2495 | SEC_LINKER_CREATED | SEC_READONLY);
2496 if (sec->flags & SEC_ALLOC)
2497 flags |= SEC_ALLOC | SEC_LOAD;
2499 || !bfd_set_section_flags (dynobj, sreloc, flags)
2500 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2507 /* Since we havn't seen all of the input symbols yet, we
2508 don't know whether we'll actually need a dynamic relocation
2509 entry for this reloc. So make a record of it. Once we
2510 find out if this thing needs dynamic relocation we'll
2511 expand the relocation sections by the appropriate amount. */
2513 struct alpha_elf_reloc_entry *rent;
2515 for (rent = h->reloc_entries; rent; rent = rent->next)
2516 if (rent->rtype == r_type && rent->srel == sreloc)
2521 amt = sizeof (struct alpha_elf_reloc_entry);
2522 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
2526 rent->srel = sreloc;
2527 rent->rtype = r_type;
2529 rent->reltext = ((sec->flags & (SEC_READONLY | SEC_ALLOC))
2530 == (SEC_READONLY | SEC_ALLOC));
2532 rent->next = h->reloc_entries;
2533 h->reloc_entries = rent;
2538 else if (info->shared && (sec->flags & SEC_ALLOC))
2540 /* If this is a shared library, and the section is to be
2541 loaded into memory, we need a RELATIVE reloc. */
2542 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2543 if (sec->flags & SEC_READONLY)
2544 info->flags |= DF_TEXTREL;
2553 /* Adjust a symbol defined by a dynamic object and referenced by a
2554 regular object. The current definition is in some section of the
2555 dynamic object, but we're not including those sections. We have to
2556 change the definition to something the rest of the link can
2560 elf64_alpha_adjust_dynamic_symbol (info, h)
2561 struct bfd_link_info *info;
2562 struct elf_link_hash_entry *h;
2566 struct alpha_elf_link_hash_entry *ah;
2568 dynobj = elf_hash_table(info)->dynobj;
2569 ah = (struct alpha_elf_link_hash_entry *)h;
2571 /* Now that we've seen all of the input symbols, finalize our decision
2572 about whether this symbol should get a .plt entry. */
2574 if (alpha_elf_dynamic_symbol_p (h, info)
2575 && ((h->type == STT_FUNC
2576 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2577 || (h->type == STT_NOTYPE
2578 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2579 /* Don't prevent otherwise valid programs from linking by attempting
2580 to create a new .got entry somewhere. A Correct Solution would be
2581 to add a new .got section to a new object file and let it be merged
2582 somewhere later. But for now don't bother. */
2585 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2587 s = bfd_get_section_by_name(dynobj, ".plt");
2588 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2591 /* The first bit of the .plt is reserved. */
2592 if (s->_raw_size == 0)
2593 s->_raw_size = PLT_HEADER_SIZE;
2595 h->plt.offset = s->_raw_size;
2596 s->_raw_size += PLT_ENTRY_SIZE;
2598 /* If this symbol is not defined in a regular file, and we are not
2599 generating a shared library, then set the symbol to the location
2600 in the .plt. This is required to make function pointers compare
2601 equal between the normal executable and the shared library. */
2603 && h->root.type != bfd_link_hash_defweak)
2605 h->root.u.def.section = s;
2606 h->root.u.def.value = h->plt.offset;
2609 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2610 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2611 BFD_ASSERT (s != NULL);
2612 s->_raw_size += sizeof (Elf64_External_Rela);
2617 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2619 /* If this is a weak symbol, and there is a real definition, the
2620 processor independent code will have arranged for us to see the
2621 real definition first, and we can just use the same value. */
2622 if (h->weakdef != NULL)
2624 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2625 || h->weakdef->root.type == bfd_link_hash_defweak);
2626 h->root.u.def.section = h->weakdef->root.u.def.section;
2627 h->root.u.def.value = h->weakdef->root.u.def.value;
2631 /* This is a reference to a symbol defined by a dynamic object which
2632 is not a function. The Alpha, since it uses .got entries for all
2633 symbols even in regular objects, does not need the hackery of a
2634 .dynbss section and COPY dynamic relocations. */
2639 /* Symbol versioning can create new symbols, and make our old symbols
2640 indirect to the new ones. Consolidate the got and reloc information
2641 in these situations. */
2644 elf64_alpha_merge_ind_symbols (hi, dummy)
2645 struct alpha_elf_link_hash_entry *hi;
2646 PTR dummy ATTRIBUTE_UNUSED;
2648 struct alpha_elf_link_hash_entry *hs;
2650 if (hi->root.root.type != bfd_link_hash_indirect)
2654 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2655 } while (hs->root.root.type == bfd_link_hash_indirect);
2657 /* Merge the flags. Whee. */
2659 hs->flags |= hi->flags;
2661 /* Merge the .got entries. Cannibalize the old symbol's list in
2662 doing so, since we don't need it anymore. */
2664 if (hs->got_entries == NULL)
2665 hs->got_entries = hi->got_entries;
2668 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2670 gsh = hs->got_entries;
2671 for (gi = hi->got_entries; gi ; gi = gin)
2674 for (gs = gsh; gs ; gs = gs->next)
2675 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2677 gi->next = hs->got_entries;
2678 hs->got_entries = gi;
2682 hi->got_entries = NULL;
2684 /* And similar for the reloc entries. */
2686 if (hs->reloc_entries == NULL)
2687 hs->reloc_entries = hi->reloc_entries;
2690 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2692 rsh = hs->reloc_entries;
2693 for (ri = hi->reloc_entries; ri ; ri = rin)
2696 for (rs = rsh; rs ; rs = rs->next)
2697 if (ri->rtype == rs->rtype)
2699 rs->count += ri->count;
2702 ri->next = hs->reloc_entries;
2703 hs->reloc_entries = ri;
2707 hi->reloc_entries = NULL;
2712 /* Is it possible to merge two object file's .got tables? */
2715 elf64_alpha_can_merge_gots (a, b)
2718 int total = alpha_elf_tdata (a)->total_got_entries;
2721 /* Trivial quick fallout test. */
2722 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2725 /* By their nature, local .got entries cannot be merged. */
2726 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2729 /* Failing the common trivial comparison, we must effectively
2730 perform the merge. Not actually performing the merge means that
2731 we don't have to store undo information in case we fail. */
2732 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2734 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2735 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2738 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2739 for (i = 0; i < n; ++i)
2741 struct alpha_elf_got_entry *ae, *be;
2742 struct alpha_elf_link_hash_entry *h;
2745 while (h->root.root.type == bfd_link_hash_indirect
2746 || h->root.root.type == bfd_link_hash_warning)
2747 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2749 for (be = h->got_entries; be ; be = be->next)
2751 if (be->use_count == 0)
2753 if (be->gotobj != b)
2756 for (ae = h->got_entries; ae ; ae = ae->next)
2757 if (ae->gotobj == a && ae->addend == be->addend)
2760 if (++total > MAX_GOT_ENTRIES)
2770 /* Actually merge two .got tables. */
2773 elf64_alpha_merge_gots (a, b)
2776 int total = alpha_elf_tdata (a)->total_got_entries;
2779 /* Remember local expansion. */
2781 int e = alpha_elf_tdata (b)->n_local_got_entries;
2783 alpha_elf_tdata (a)->n_local_got_entries += e;
2786 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2788 struct alpha_elf_got_entry **local_got_entries;
2789 struct alpha_elf_link_hash_entry **hashes;
2790 Elf_Internal_Shdr *symtab_hdr;
2793 /* Let the local .got entries know they are part of a new subsegment. */
2794 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2795 if (local_got_entries)
2797 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2798 for (i = 0; i < n; ++i)
2800 struct alpha_elf_got_entry *ent;
2801 for (ent = local_got_entries[i]; ent; ent = ent->next)
2806 /* Merge the global .got entries. */
2807 hashes = alpha_elf_sym_hashes (bsub);
2808 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2810 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2811 for (i = 0; i < n; ++i)
2813 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2814 struct alpha_elf_link_hash_entry *h;
2817 while (h->root.root.type == bfd_link_hash_indirect
2818 || h->root.root.type == bfd_link_hash_warning)
2819 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2821 start = &h->got_entries;
2822 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2824 if (be->use_count == 0)
2829 if (be->gotobj != b)
2832 for (ae = *start; ae ; ae = ae->next)
2833 if (ae->gotobj == a && ae->addend == be->addend)
2835 ae->flags |= be->flags;
2836 ae->use_count += be->use_count;
2847 alpha_elf_tdata (bsub)->gotobj = a;
2849 alpha_elf_tdata (a)->total_got_entries = total;
2851 /* Merge the two in_got chains. */
2856 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2859 alpha_elf_tdata (bsub)->in_got_link_next = b;
2863 /* Calculate the offsets for the got entries. */
2866 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2867 struct alpha_elf_link_hash_entry *h;
2868 PTR arg ATTRIBUTE_UNUSED;
2870 struct alpha_elf_got_entry *gotent;
2872 if (h->root.root.type == bfd_link_hash_warning)
2873 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2875 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2876 if (gotent->use_count > 0)
2879 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2881 gotent->got_offset = *plge;
2889 elf64_alpha_calc_got_offsets (info)
2890 struct bfd_link_info *info;
2892 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2894 /* First, zero out the .got sizes, as we may be recalculating the
2895 .got after optimizing it. */
2896 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2897 alpha_elf_tdata(i)->got->_raw_size = 0;
2899 /* Next, fill in the offsets for all the global entries. */
2900 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2901 elf64_alpha_calc_got_offsets_for_symbol,
2904 /* Finally, fill in the offsets for the local entries. */
2905 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2907 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2910 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2912 struct alpha_elf_got_entry **local_got_entries, *gotent;
2915 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2916 if (!local_got_entries)
2919 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2920 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2921 if (gotent->use_count > 0)
2923 gotent->got_offset = got_offset;
2928 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2929 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2933 /* Constructs the gots. */
2936 elf64_alpha_size_got_sections (output_bfd, info)
2937 bfd *output_bfd ATTRIBUTE_UNUSED;
2938 struct bfd_link_info *info;
2940 bfd *i, *got_list, *cur_got_obj = NULL;
2941 int something_changed = 0;
2943 got_list = alpha_elf_hash_table (info)->got_list;
2945 /* On the first time through, pretend we have an existing got list
2946 consisting of all of the input files. */
2947 if (got_list == NULL)
2949 for (i = info->input_bfds; i ; i = i->link_next)
2951 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2952 if (this_got == NULL)
2955 /* We are assuming no merging has yet ocurred. */
2956 BFD_ASSERT (this_got == i);
2958 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
2960 /* Yikes! A single object file has too many entries. */
2961 (*_bfd_error_handler)
2962 (_("%s: .got subsegment exceeds 64K (size %d)"),
2963 bfd_archive_filename (i),
2964 alpha_elf_tdata (this_got)->total_got_entries * 8);
2968 if (got_list == NULL)
2969 got_list = this_got;
2971 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2972 cur_got_obj = this_got;
2975 /* Strange degenerate case of no got references. */
2976 if (got_list == NULL)
2979 alpha_elf_hash_table (info)->got_list = got_list;
2981 /* Force got offsets to be recalculated. */
2982 something_changed = 1;
2985 cur_got_obj = got_list;
2986 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2989 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2991 elf64_alpha_merge_gots (cur_got_obj, i);
2992 i = alpha_elf_tdata(i)->got_link_next;
2993 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2994 something_changed = 1;
2999 i = alpha_elf_tdata(i)->got_link_next;
3003 /* Once the gots have been merged, fill in the got offsets for
3004 everything therein. */
3005 if (1 || something_changed)
3006 elf64_alpha_calc_got_offsets (info);
3012 elf64_alpha_always_size_sections (output_bfd, info)
3014 struct bfd_link_info *info;
3018 if (info->relocateable)
3021 /* First, take care of the indirect symbols created by versioning. */
3022 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3023 elf64_alpha_merge_ind_symbols,
3026 if (!elf64_alpha_size_got_sections (output_bfd, info))
3029 /* Allocate space for all of the .got subsections. */
3030 i = alpha_elf_hash_table (info)->got_list;
3031 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3033 asection *s = alpha_elf_tdata(i)->got;
3034 if (s->_raw_size > 0)
3036 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3037 if (s->contents == NULL)
3045 /* Work out the sizes of the dynamic relocation entries. */
3048 elf64_alpha_calc_dynrel_sizes (h, info)
3049 struct alpha_elf_link_hash_entry *h;
3050 struct bfd_link_info *info;
3052 if (h->root.root.type == bfd_link_hash_warning)
3053 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3055 /* If the symbol was defined as a common symbol in a regular object
3056 file, and there was no definition in any dynamic object, then the
3057 linker will have allocated space for the symbol in a common
3058 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3059 set. This is done for dynamic symbols in
3060 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3061 symbols, somehow. */
3062 if (((h->root.elf_link_hash_flags
3063 & (ELF_LINK_HASH_DEF_REGULAR
3064 | ELF_LINK_HASH_REF_REGULAR
3065 | ELF_LINK_HASH_DEF_DYNAMIC))
3066 == ELF_LINK_HASH_REF_REGULAR)
3067 && (h->root.root.type == bfd_link_hash_defined
3068 || h->root.root.type == bfd_link_hash_defweak)
3069 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3071 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3074 /* If the symbol is dynamic, we'll need all the relocations in their
3075 natural form. If this is a shared object, and it has been forced
3076 local, we'll need the same number of RELATIVE relocations. */
3078 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3080 struct alpha_elf_reloc_entry *relent;
3082 struct alpha_elf_got_entry *gotent;
3083 bfd_size_type count;
3086 for (relent = h->reloc_entries; relent; relent = relent->next)
3087 if (relent->rtype == R_ALPHA_REFLONG
3088 || relent->rtype == R_ALPHA_REFQUAD)
3090 relent->srel->_raw_size +=
3091 sizeof (Elf64_External_Rela) * relent->count;
3092 if (relent->reltext)
3093 info->flags |= DT_TEXTREL;
3096 dynobj = elf_hash_table(info)->dynobj;
3099 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3102 /* If we are using a .plt entry, subtract one, as the first
3103 reference uses a .rela.plt entry instead. */
3104 if (h->root.plt.offset != MINUS_ONE)
3109 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3110 BFD_ASSERT (srel != NULL);
3111 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3118 /* Set the sizes of the dynamic sections. */
3121 elf64_alpha_size_dynamic_sections (output_bfd, info)
3122 bfd *output_bfd ATTRIBUTE_UNUSED;
3123 struct bfd_link_info *info;
3129 dynobj = elf_hash_table(info)->dynobj;
3130 BFD_ASSERT(dynobj != NULL);
3132 if (elf_hash_table (info)->dynamic_sections_created)
3134 /* Set the contents of the .interp section to the interpreter. */
3137 s = bfd_get_section_by_name (dynobj, ".interp");
3138 BFD_ASSERT (s != NULL);
3139 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3140 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3143 /* Now that we've seen all of the input files, we can decide which
3144 symbols need dynamic relocation entries and which don't. We've
3145 collected information in check_relocs that we can now apply to
3146 size the dynamic relocation sections. */
3147 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3148 elf64_alpha_calc_dynrel_sizes,
3151 /* When building shared libraries, each local .got entry needs a
3157 bfd_size_type count;
3159 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3160 BFD_ASSERT (srel != NULL);
3162 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3164 i = alpha_elf_tdata(i)->got_link_next)
3165 count += alpha_elf_tdata(i)->n_local_got_entries;
3167 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3170 /* else we're not dynamic and by definition we don't need such things. */
3172 /* The check_relocs and adjust_dynamic_symbol entry points have
3173 determined the sizes of the various dynamic sections. Allocate
3176 for (s = dynobj->sections; s != NULL; s = s->next)
3181 if (!(s->flags & SEC_LINKER_CREATED))
3184 /* It's OK to base decisions on the section name, because none
3185 of the dynobj section names depend upon the input files. */
3186 name = bfd_get_section_name (dynobj, s);
3188 /* If we don't need this section, strip it from the output file.
3189 This is to handle .rela.bss and .rela.plt. We must create it
3190 in create_dynamic_sections, because it must be created before
3191 the linker maps input sections to output sections. The
3192 linker does that before adjust_dynamic_symbol is called, and
3193 it is that function which decides whether anything needs to
3194 go into these sections. */
3198 if (strncmp (name, ".rela", 5) == 0)
3200 strip = (s->_raw_size == 0);
3204 if (strcmp(name, ".rela.plt") == 0)
3207 /* We use the reloc_count field as a counter if we need
3208 to copy relocs into the output file. */
3212 else if (strcmp (name, ".plt") != 0)
3214 /* It's not one of our dynamic sections, so don't allocate space. */
3219 _bfd_strip_section_from_output (info, s);
3222 /* Allocate memory for the section contents. */
3223 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3224 if (s->contents == NULL && s->_raw_size != 0)
3229 if (elf_hash_table (info)->dynamic_sections_created)
3231 /* Add some entries to the .dynamic section. We fill in the
3232 values later, in elf64_alpha_finish_dynamic_sections, but we
3233 must add the entries now so that we get the correct size for
3234 the .dynamic section. The DT_DEBUG entry is filled in by the
3235 dynamic linker and used by the debugger. */
3236 #define add_dynamic_entry(TAG, VAL) \
3237 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3241 if (!add_dynamic_entry (DT_DEBUG, 0))
3247 if (!add_dynamic_entry (DT_PLTGOT, 0)
3248 || !add_dynamic_entry (DT_PLTRELSZ, 0)
3249 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3250 || !add_dynamic_entry (DT_JMPREL, 0))
3254 if (!add_dynamic_entry (DT_RELA, 0)
3255 || !add_dynamic_entry (DT_RELASZ, 0)
3256 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
3259 if (info->flags & DF_TEXTREL)
3261 if (!add_dynamic_entry (DT_TEXTREL, 0))
3265 #undef add_dynamic_entry
3270 /* Relocate an Alpha ELF section. */
3273 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3274 contents, relocs, local_syms, local_sections)
3276 struct bfd_link_info *info;
3278 asection *input_section;
3280 Elf_Internal_Rela *relocs;
3281 Elf_Internal_Sym *local_syms;
3282 asection **local_sections;
3284 Elf_Internal_Shdr *symtab_hdr;
3285 Elf_Internal_Rela *rel;
3286 Elf_Internal_Rela *relend;
3287 asection *sec, *sgot, *srel, *srelgot;
3288 bfd *dynobj, *gotobj;
3290 boolean ret_val = true;
3292 srelgot = srel = NULL;
3293 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3294 dynobj = elf_hash_table (info)->dynobj;
3297 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3300 /* Find the gp value for this input bfd. */
3303 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3306 sgot = alpha_elf_tdata (gotobj)->got;
3307 gp = _bfd_get_gp_value (gotobj);
3310 gp = (sgot->output_section->vma
3311 + sgot->output_offset
3313 _bfd_set_gp_value (gotobj, gp);
3318 relend = relocs + input_section->reloc_count;
3319 for (; rel < relend; rel++)
3322 reloc_howto_type *howto;
3323 unsigned long r_symndx;
3324 struct alpha_elf_link_hash_entry *h;
3325 Elf_Internal_Sym *sym;
3328 bfd_reloc_status_type r;
3330 r_type = ELF64_R_TYPE(rel->r_info);
3331 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3333 bfd_set_error (bfd_error_bad_value);
3336 howto = elf64_alpha_howto_table + r_type;
3338 r_symndx = ELF64_R_SYM(rel->r_info);
3340 if (info->relocateable)
3342 /* This is a relocateable link. We don't have to change
3343 anything, unless the reloc is against a section symbol,
3344 in which case we have to adjust according to where the
3345 section symbol winds up in the output section. */
3347 /* The symbol associated with GPDISP and LITUSE is
3348 immaterial. Only the addend is significant. */
3349 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3352 if (r_symndx < symtab_hdr->sh_info)
3354 sym = local_syms + r_symndx;
3355 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3357 sec = local_sections[r_symndx];
3358 rel->r_addend += sec->output_offset + sym->st_value;
3365 /* This is a final link. */
3371 if (r_symndx < symtab_hdr->sh_info)
3373 sym = local_syms + r_symndx;
3374 sec = local_sections[r_symndx];
3375 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
3379 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3381 while (h->root.root.type == bfd_link_hash_indirect
3382 || h->root.root.type == bfd_link_hash_warning)
3383 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3385 if (h->root.root.type == bfd_link_hash_defined
3386 || h->root.root.type == bfd_link_hash_defweak)
3388 sec = h->root.root.u.def.section;
3390 if (sec->output_section == NULL)
3394 relocation = (h->root.root.u.def.value
3395 + sec->output_section->vma
3396 + sec->output_offset);
3399 else if (h->root.root.type == bfd_link_hash_undefweak)
3401 else if (info->shared
3402 && (!info->symbolic || info->allow_shlib_undefined)
3403 && !info->no_undefined
3404 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3408 if (!((*info->callbacks->undefined_symbol)
3409 (info, h->root.root.root.string, input_bfd,
3410 input_section, rel->r_offset,
3411 (!info->shared || info->no_undefined
3412 || ELF_ST_VISIBILITY (h->root.other)))))
3417 addend = rel->r_addend;
3421 case R_ALPHA_GPDISP:
3423 bfd_byte *p_ldah, *p_lda;
3425 BFD_ASSERT(gp != 0);
3427 relocation = (input_section->output_section->vma
3428 + input_section->output_offset
3431 p_ldah = contents + rel->r_offset - input_section->vma;
3432 p_lda = p_ldah + rel->r_addend;
3434 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3439 case R_ALPHA_LITERAL:
3441 struct alpha_elf_got_entry *gotent;
3442 boolean dynamic_symbol;
3444 BFD_ASSERT(sgot != NULL);
3445 BFD_ASSERT(gp != 0);
3449 gotent = h->got_entries;
3450 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3454 gotent = (alpha_elf_tdata(input_bfd)->
3455 local_got_entries[r_symndx]);
3456 dynamic_symbol = false;
3458 /* Need to adjust local GOT entries' addends for SEC_MERGE
3459 unless it has been done already. */
3460 if ((sec->flags & SEC_MERGE)
3461 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3462 && (elf_section_data (sec)->sec_info_type
3463 == ELF_INFO_TYPE_MERGE)
3464 && (gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED) == 0)
3466 struct alpha_elf_got_entry *ent;
3469 for (ent = gotent; ent; ent = ent->next)
3471 ent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_XLATED;
3472 if (ent->use_count == 0)
3476 _bfd_merged_section_offset (output_bfd, &msec,
3477 elf_section_data (sec)->
3482 ent->addend -= sym->st_value;
3483 ent->addend += msec->output_section->vma
3484 + msec->output_offset
3485 - sec->output_section->vma
3486 - sec->output_offset;
3491 BFD_ASSERT(gotent != NULL);
3493 while (gotent->gotobj != gotobj || gotent->addend != addend)
3494 gotent = gotent->next;
3496 BFD_ASSERT(gotent->use_count >= 1);
3498 /* Initialize the .got entry's value. */
3499 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3501 bfd_put_64 (output_bfd, relocation + addend,
3502 sgot->contents + gotent->got_offset);
3504 /* If the symbol has been forced local, output a
3505 RELATIVE reloc, otherwise it will be handled in
3506 finish_dynamic_symbol. */
3507 if (info->shared && !dynamic_symbol)
3509 Elf_Internal_Rela outrel;
3511 BFD_ASSERT(srelgot != NULL);
3513 outrel.r_offset = (sgot->output_section->vma
3514 + sgot->output_offset
3515 + gotent->got_offset);
3516 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3517 outrel.r_addend = relocation + addend;
3519 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3520 ((Elf64_External_Rela *)
3522 + srelgot->reloc_count++);
3523 BFD_ASSERT (sizeof (Elf64_External_Rela)
3524 * srelgot->reloc_count
3525 <= srelgot->_cooked_size);
3528 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3531 /* Figure the gprel relocation. */
3533 relocation = (sgot->output_section->vma
3534 + sgot->output_offset
3535 + gotent->got_offset);
3538 /* overflow handled by _bfd_final_link_relocate */
3541 case R_ALPHA_GPREL16:
3542 case R_ALPHA_GPREL32:
3543 case R_ALPHA_GPRELLOW:
3544 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3546 (*_bfd_error_handler)
3547 (_("%s: gp-relative relocation against dynamic symbol %s"),
3548 bfd_archive_filename (input_bfd), h->root.root.root.string);
3551 BFD_ASSERT(gp != 0);
3555 case R_ALPHA_GPRELHIGH:
3556 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3558 (*_bfd_error_handler)
3559 (_("%s: gp-relative relocation against dynamic symbol %s"),
3560 bfd_archive_filename (input_bfd), h->root.root.root.string);
3563 BFD_ASSERT(gp != 0);
3565 relocation += addend;
3567 relocation = (((bfd_signed_vma) relocation >> 16)
3568 + ((relocation >> 15) & 1));
3572 /* A call to a dynamic symbol is definitely out of range of
3573 the 16-bit displacement. Don't bother writing anything. */
3574 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3581 case R_ALPHA_BRADDR:
3582 /* The regular PC-relative stuff measures from the start of
3583 the instruction rather than the end. */
3592 /* The regular PC-relative stuff measures from the start of
3593 the instruction rather than the end. */
3596 /* The source and destination gp must be the same. Note that
3597 the source will always have an assigned gp, since we forced
3598 one in check_relocs, but that the destination may not, as
3599 it might not have had any relocations at all. Also take
3600 care not to crash if H is an undefined symbol. */
3601 if (h != NULL && sec != NULL
3602 && alpha_elf_tdata (sec->owner)->gotobj
3603 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
3605 (*_bfd_error_handler)
3606 (_("%s: change in gp: BRSGP %s"),
3607 bfd_archive_filename (input_bfd), h->root.root.root.string);
3611 /* The symbol should be marked either NOPV or STD_GPLOAD. */
3613 other = h->root.other;
3615 other = sym->st_other;
3616 switch (other & STO_ALPHA_STD_GPLOAD)
3618 case STO_ALPHA_NOPV:
3620 case STO_ALPHA_STD_GPLOAD:
3625 name = h->root.root.root.string;
3628 name = (bfd_elf_string_from_elf_section
3629 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3631 name = _("<unknown>");
3632 else if (name[0] == 0)
3633 name = bfd_section_name (input_bfd, sec);
3635 (*_bfd_error_handler)
3636 (_("%s: !samegp reloc against symbol without .prologue: %s"),
3637 bfd_archive_filename (input_bfd), name);
3645 case R_ALPHA_REFLONG:
3646 case R_ALPHA_REFQUAD:
3648 Elf_Internal_Rela outrel;
3650 /* Careful here to remember RELATIVE relocations for global
3651 variables for symbolic shared objects. */
3653 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3655 BFD_ASSERT(h->root.dynindx != -1);
3656 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3657 outrel.r_addend = addend;
3658 addend = 0, relocation = 0;
3660 else if (info->shared
3662 && (input_section->flags & SEC_ALLOC))
3664 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3665 outrel.r_addend = relocation + addend;
3674 name = (bfd_elf_string_from_elf_section
3675 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3676 elf_section_data(input_section)->rel_hdr.sh_name));
3677 BFD_ASSERT(name != NULL);
3679 srel = bfd_get_section_by_name (dynobj, name);
3680 BFD_ASSERT(srel != NULL);
3684 _bfd_elf_section_offset (output_bfd, info, input_section,
3686 if ((outrel.r_offset | 1) != (bfd_vma) -1)
3687 outrel.r_offset += (input_section->output_section->vma
3688 + input_section->output_offset);
3690 memset (&outrel, 0, sizeof outrel);
3692 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3693 ((Elf64_External_Rela *)
3695 + srel->reloc_count++);
3696 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3697 <= srel->_cooked_size);
3701 case R_ALPHA_SREL32:
3702 case R_ALPHA_SREL64:
3703 /* ??? .eh_frame references to discarded sections will be smashed
3704 to relocations against SHN_UNDEF. The .eh_frame format allows
3705 NULL to be encoded as 0 in any format, so this works here. */
3707 howto = (elf64_alpha_howto_table
3708 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
3713 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3714 contents, rel->r_offset, relocation,
3724 case bfd_reloc_overflow:
3728 /* Don't warn if the overflow is due to pc relative reloc
3729 against discarded section. Section optimization code should
3732 if (r_symndx < symtab_hdr->sh_info
3733 && sec != NULL && howto->pc_relative
3734 && elf_discarded_section (sec))
3738 name = h->root.root.root.string;
3741 name = (bfd_elf_string_from_elf_section
3742 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3746 name = bfd_section_name (input_bfd, sec);
3748 if (! ((*info->callbacks->reloc_overflow)
3749 (info, name, howto->name, (bfd_vma) 0,
3750 input_bfd, input_section, rel->r_offset)))
3756 case bfd_reloc_outofrange:
3764 /* Finish up dynamic symbol handling. We set the contents of various
3765 dynamic sections here. */
3768 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3770 struct bfd_link_info *info;
3771 struct elf_link_hash_entry *h;
3772 Elf_Internal_Sym *sym;
3774 bfd *dynobj = elf_hash_table(info)->dynobj;
3776 if (h->plt.offset != MINUS_ONE)
3778 /* Fill in the .plt entry for this symbol. */
3779 asection *splt, *sgot, *srel;
3780 Elf_Internal_Rela outrel;
3781 bfd_vma got_addr, plt_addr;
3783 struct alpha_elf_got_entry *gotent;
3785 BFD_ASSERT (h->dynindx != -1);
3787 /* The first .got entry will be updated by the .plt with the
3788 address of the target function. */
3789 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3790 BFD_ASSERT (gotent && gotent->addend == 0);
3792 splt = bfd_get_section_by_name (dynobj, ".plt");
3793 BFD_ASSERT (splt != NULL);
3794 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3795 BFD_ASSERT (srel != NULL);
3796 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3797 BFD_ASSERT (sgot != NULL);
3799 got_addr = (sgot->output_section->vma
3800 + sgot->output_offset
3801 + gotent->got_offset);
3802 plt_addr = (splt->output_section->vma
3803 + splt->output_offset
3806 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3808 /* Fill in the entry in the procedure linkage table. */
3810 bfd_vma insn1, insn2, insn3;
3812 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3813 insn2 = PLT_ENTRY_WORD2;
3814 insn3 = PLT_ENTRY_WORD3;
3816 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3817 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3818 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3821 /* Fill in the entry in the .rela.plt section. */
3822 outrel.r_offset = got_addr;
3823 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3824 outrel.r_addend = 0;
3826 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3827 ((Elf64_External_Rela *)srel->contents
3830 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3832 /* Mark the symbol as undefined, rather than as defined in the
3833 .plt section. Leave the value alone. */
3834 sym->st_shndx = SHN_UNDEF;
3837 /* Fill in the entries in the .got. */
3838 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3840 /* Subsequent .got entries will continue to bounce through the .plt. */
3843 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3844 BFD_ASSERT (! info->shared || srel != NULL);
3846 gotent = gotent->next;
3849 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3850 BFD_ASSERT(sgot != NULL);
3851 BFD_ASSERT(gotent->addend == 0);
3853 bfd_put_64 (output_bfd, plt_addr,
3854 sgot->contents + gotent->got_offset);
3858 outrel.r_offset = (sgot->output_section->vma
3859 + sgot->output_offset
3860 + gotent->got_offset);
3861 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3862 outrel.r_addend = plt_addr;
3864 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3865 ((Elf64_External_Rela *)
3867 + srel->reloc_count++);
3868 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3869 <= srel->_cooked_size);
3872 gotent = gotent->next;
3874 while (gotent != NULL);
3877 else if (alpha_elf_dynamic_symbol_p (h, info))
3879 /* Fill in the dynamic relocations for this symbol's .got entries. */
3881 Elf_Internal_Rela outrel;
3882 struct alpha_elf_got_entry *gotent;
3884 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3885 BFD_ASSERT (srel != NULL);
3887 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3888 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3890 gotent = gotent->next)
3892 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3893 outrel.r_offset = (sgot->output_section->vma
3894 + sgot->output_offset
3895 + gotent->got_offset);
3896 outrel.r_addend = gotent->addend;
3898 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3899 ((Elf64_External_Rela *)srel->contents
3900 + srel->reloc_count++));
3901 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3902 <= srel->_cooked_size);
3906 /* Mark some specially defined symbols as absolute. */
3907 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3908 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3909 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3910 sym->st_shndx = SHN_ABS;
3915 /* Finish up the dynamic sections. */
3918 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3920 struct bfd_link_info *info;
3925 dynobj = elf_hash_table (info)->dynobj;
3926 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3928 if (elf_hash_table (info)->dynamic_sections_created)
3931 Elf64_External_Dyn *dyncon, *dynconend;
3933 splt = bfd_get_section_by_name (dynobj, ".plt");
3934 BFD_ASSERT (splt != NULL && sdyn != NULL);
3936 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3937 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3938 for (; dyncon < dynconend; dyncon++)
3940 Elf_Internal_Dyn dyn;
3944 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3959 /* My interpretation of the TIS v1.1 ELF document indicates
3960 that RELASZ should not include JMPREL. This is not what
3961 the rest of the BFD does. It is, however, what the
3962 glibc ld.so wants. Do this fixup here until we found
3963 out who is right. */
3964 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3968 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3973 s = bfd_get_section_by_name (output_bfd, name);
3974 dyn.d_un.d_ptr = (s ? s->vma : 0);
3978 s = bfd_get_section_by_name (output_bfd, name);
3980 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3984 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3987 /* Initialize the PLT0 entry */
3988 if (splt->_raw_size > 0)
3990 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3991 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3992 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3993 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3995 /* The next two words will be filled in by ld.so */
3996 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
3997 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
3999 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
4007 /* We need to use a special link routine to handle the .mdebug section.
4008 We need to merge all instances of these sections together, not write
4009 them all out sequentially. */
4012 elf64_alpha_final_link (abfd, info)
4014 struct bfd_link_info *info;
4017 struct bfd_link_order *p;
4018 asection *mdebug_sec;
4019 struct ecoff_debug_info debug;
4020 const struct ecoff_debug_swap *swap
4021 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4022 HDRR *symhdr = &debug.symbolic_header;
4023 PTR mdebug_handle = NULL;
4025 /* Go through the sections and collect the mdebug information. */
4027 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4029 if (strcmp (o->name, ".mdebug") == 0)
4031 struct extsym_info einfo;
4033 /* We have found the .mdebug section in the output file.
4034 Look through all the link_orders comprising it and merge
4035 the information together. */
4036 symhdr->magic = swap->sym_magic;
4037 /* FIXME: What should the version stamp be? */
4039 symhdr->ilineMax = 0;
4043 symhdr->isymMax = 0;
4044 symhdr->ioptMax = 0;
4045 symhdr->iauxMax = 0;
4047 symhdr->issExtMax = 0;
4050 symhdr->iextMax = 0;
4052 /* We accumulate the debugging information itself in the
4053 debug_info structure. */
4055 debug.external_dnr = NULL;
4056 debug.external_pdr = NULL;
4057 debug.external_sym = NULL;
4058 debug.external_opt = NULL;
4059 debug.external_aux = NULL;
4061 debug.ssext = debug.ssext_end = NULL;
4062 debug.external_fdr = NULL;
4063 debug.external_rfd = NULL;
4064 debug.external_ext = debug.external_ext_end = NULL;
4066 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4067 if (mdebug_handle == (PTR) NULL)
4076 static const char * const name[] =
4078 ".text", ".init", ".fini", ".data",
4079 ".rodata", ".sdata", ".sbss", ".bss"
4081 static const int sc[] = { scText, scInit, scFini, scData,
4082 scRData, scSData, scSBss, scBss };
4085 esym.cobol_main = 0;
4089 esym.asym.iss = issNil;
4090 esym.asym.st = stLocal;
4091 esym.asym.reserved = 0;
4092 esym.asym.index = indexNil;
4093 for (i = 0; i < 8; i++)
4095 esym.asym.sc = sc[i];
4096 s = bfd_get_section_by_name (abfd, name[i]);
4099 esym.asym.value = s->vma;
4100 last = s->vma + s->_raw_size;
4103 esym.asym.value = last;
4105 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4111 for (p = o->link_order_head;
4112 p != (struct bfd_link_order *) NULL;
4115 asection *input_section;
4117 const struct ecoff_debug_swap *input_swap;
4118 struct ecoff_debug_info input_debug;
4122 if (p->type != bfd_indirect_link_order)
4124 if (p->type == bfd_fill_link_order)
4129 input_section = p->u.indirect.section;
4130 input_bfd = input_section->owner;
4132 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4133 || (get_elf_backend_data (input_bfd)
4134 ->elf_backend_ecoff_debug_swap) == NULL)
4136 /* I don't know what a non ALPHA ELF bfd would be
4137 doing with a .mdebug section, but I don't really
4138 want to deal with it. */
4142 input_swap = (get_elf_backend_data (input_bfd)
4143 ->elf_backend_ecoff_debug_swap);
4145 BFD_ASSERT (p->size == input_section->_raw_size);
4147 /* The ECOFF linking code expects that we have already
4148 read in the debugging information and set up an
4149 ecoff_debug_info structure, so we do that now. */
4150 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4154 if (! (bfd_ecoff_debug_accumulate
4155 (mdebug_handle, abfd, &debug, swap, input_bfd,
4156 &input_debug, input_swap, info)))
4159 /* Loop through the external symbols. For each one with
4160 interesting information, try to find the symbol in
4161 the linker global hash table and save the information
4162 for the output external symbols. */
4163 eraw_src = input_debug.external_ext;
4164 eraw_end = (eraw_src
4165 + (input_debug.symbolic_header.iextMax
4166 * input_swap->external_ext_size));
4168 eraw_src < eraw_end;
4169 eraw_src += input_swap->external_ext_size)
4173 struct alpha_elf_link_hash_entry *h;
4175 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4176 if (ext.asym.sc == scNil
4177 || ext.asym.sc == scUndefined
4178 || ext.asym.sc == scSUndefined)
4181 name = input_debug.ssext + ext.asym.iss;
4182 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4183 name, false, false, true);
4184 if (h == NULL || h->esym.ifd != -2)
4190 < input_debug.symbolic_header.ifdMax);
4191 ext.ifd = input_debug.ifdmap[ext.ifd];
4197 /* Free up the information we just read. */
4198 free (input_debug.line);
4199 free (input_debug.external_dnr);
4200 free (input_debug.external_pdr);
4201 free (input_debug.external_sym);
4202 free (input_debug.external_opt);
4203 free (input_debug.external_aux);
4204 free (input_debug.ss);
4205 free (input_debug.ssext);
4206 free (input_debug.external_fdr);
4207 free (input_debug.external_rfd);
4208 free (input_debug.external_ext);
4210 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4211 elf_link_input_bfd ignores this section. */
4212 input_section->flags &=~ SEC_HAS_CONTENTS;
4215 /* Build the external symbol information. */
4218 einfo.debug = &debug;
4220 einfo.failed = false;
4221 elf_link_hash_traverse (elf_hash_table (info),
4222 elf64_alpha_output_extsym,
4227 /* Set the size of the .mdebug section. */
4228 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4230 /* Skip this section later on (I don't think this currently
4231 matters, but someday it might). */
4232 o->link_order_head = (struct bfd_link_order *) NULL;
4238 /* Invoke the regular ELF backend linker to do all the work. */
4239 if (! bfd_elf64_bfd_final_link (abfd, info))
4242 /* Now write out the computed sections. */
4244 /* The .got subsections... */
4246 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4247 for (i = alpha_elf_hash_table(info)->got_list;
4249 i = alpha_elf_tdata(i)->got_link_next)
4253 /* elf_bfd_final_link already did everything in dynobj. */
4257 sgot = alpha_elf_tdata(i)->got;
4258 if (! bfd_set_section_contents (abfd, sgot->output_section,
4260 (file_ptr) sgot->output_offset,
4266 if (mdebug_sec != (asection *) NULL)
4268 BFD_ASSERT (abfd->output_has_begun);
4269 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4271 mdebug_sec->filepos))
4274 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4280 static enum elf_reloc_type_class
4281 elf64_alpha_reloc_type_class (rela)
4282 const Elf_Internal_Rela *rela;
4284 switch ((int) ELF64_R_TYPE (rela->r_info))
4286 case R_ALPHA_RELATIVE:
4287 return reloc_class_relative;
4288 case R_ALPHA_JMP_SLOT:
4289 return reloc_class_plt;
4291 return reloc_class_copy;
4293 return reloc_class_normal;
4297 /* ECOFF swapping routines. These are used when dealing with the
4298 .mdebug section, which is in the ECOFF debugging format. Copied
4299 from elf32-mips.c. */
4300 static const struct ecoff_debug_swap
4301 elf64_alpha_ecoff_debug_swap =
4303 /* Symbol table magic number. */
4305 /* Alignment of debugging information. E.g., 4. */
4307 /* Sizes of external symbolic information. */
4308 sizeof (struct hdr_ext),
4309 sizeof (struct dnr_ext),
4310 sizeof (struct pdr_ext),
4311 sizeof (struct sym_ext),
4312 sizeof (struct opt_ext),
4313 sizeof (struct fdr_ext),
4314 sizeof (struct rfd_ext),
4315 sizeof (struct ext_ext),
4316 /* Functions to swap in external symbolic data. */
4325 _bfd_ecoff_swap_tir_in,
4326 _bfd_ecoff_swap_rndx_in,
4327 /* Functions to swap out external symbolic data. */
4336 _bfd_ecoff_swap_tir_out,
4337 _bfd_ecoff_swap_rndx_out,
4338 /* Function to read in symbolic data. */
4339 elf64_alpha_read_ecoff_info
4342 /* Use a non-standard hash bucket size of 8. */
4344 const struct elf_size_info alpha_elf_size_info =
4346 sizeof (Elf64_External_Ehdr),
4347 sizeof (Elf64_External_Phdr),
4348 sizeof (Elf64_External_Shdr),
4349 sizeof (Elf64_External_Rel),
4350 sizeof (Elf64_External_Rela),
4351 sizeof (Elf64_External_Sym),
4352 sizeof (Elf64_External_Dyn),
4353 sizeof (Elf_External_Note),
4357 ELFCLASS64, EV_CURRENT,
4358 bfd_elf64_write_out_phdrs,
4359 bfd_elf64_write_shdrs_and_ehdr,
4360 bfd_elf64_write_relocs,
4361 bfd_elf64_swap_symbol_out,
4362 bfd_elf64_slurp_reloc_table,
4363 bfd_elf64_slurp_symbol_table,
4364 bfd_elf64_swap_dyn_in,
4365 bfd_elf64_swap_dyn_out,
4372 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4373 #define TARGET_LITTLE_NAME "elf64-alpha"
4374 #define ELF_ARCH bfd_arch_alpha
4375 #define ELF_MACHINE_CODE EM_ALPHA
4376 #define ELF_MAXPAGESIZE 0x10000
4378 #define bfd_elf64_bfd_link_hash_table_create \
4379 elf64_alpha_bfd_link_hash_table_create
4381 #define bfd_elf64_bfd_reloc_type_lookup \
4382 elf64_alpha_bfd_reloc_type_lookup
4383 #define elf_info_to_howto \
4384 elf64_alpha_info_to_howto
4386 #define bfd_elf64_mkobject \
4387 elf64_alpha_mkobject
4388 #define elf_backend_object_p \
4389 elf64_alpha_object_p
4391 #define elf_backend_section_from_shdr \
4392 elf64_alpha_section_from_shdr
4393 #define elf_backend_section_flags \
4394 elf64_alpha_section_flags
4395 #define elf_backend_fake_sections \
4396 elf64_alpha_fake_sections
4398 #define bfd_elf64_bfd_is_local_label_name \
4399 elf64_alpha_is_local_label_name
4400 #define bfd_elf64_find_nearest_line \
4401 elf64_alpha_find_nearest_line
4402 #define bfd_elf64_bfd_relax_section \
4403 elf64_alpha_relax_section
4405 #define elf_backend_add_symbol_hook \
4406 elf64_alpha_add_symbol_hook
4407 #define elf_backend_check_relocs \
4408 elf64_alpha_check_relocs
4409 #define elf_backend_create_dynamic_sections \
4410 elf64_alpha_create_dynamic_sections
4411 #define elf_backend_adjust_dynamic_symbol \
4412 elf64_alpha_adjust_dynamic_symbol
4413 #define elf_backend_always_size_sections \
4414 elf64_alpha_always_size_sections
4415 #define elf_backend_size_dynamic_sections \
4416 elf64_alpha_size_dynamic_sections
4417 #define elf_backend_relocate_section \
4418 elf64_alpha_relocate_section
4419 #define elf_backend_finish_dynamic_symbol \
4420 elf64_alpha_finish_dynamic_symbol
4421 #define elf_backend_finish_dynamic_sections \
4422 elf64_alpha_finish_dynamic_sections
4423 #define bfd_elf64_bfd_final_link \
4424 elf64_alpha_final_link
4425 #define elf_backend_reloc_type_class \
4426 elf64_alpha_reloc_type_class
4428 #define elf_backend_ecoff_debug_swap \
4429 &elf64_alpha_ecoff_debug_swap
4431 #define elf_backend_size_info \
4434 /* A few constants that determine how the .plt section is set up. */
4435 #define elf_backend_want_got_plt 0
4436 #define elf_backend_plt_readonly 0
4437 #define elf_backend_want_plt_sym 1
4438 #define elf_backend_got_header_size 0
4439 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4441 #include "elf64-target.h"