1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
52 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
54 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
66 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd *, bfd_reloc_code_real_type));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
77 static boolean elf64_alpha_fake_sections
78 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
79 static boolean elf64_alpha_create_got_section
80 PARAMS((bfd *, struct bfd_link_info *));
81 static boolean elf64_alpha_create_dynamic_sections
82 PARAMS((bfd *, struct bfd_link_info *));
84 static boolean elf64_alpha_read_ecoff_info
85 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
86 static boolean elf64_alpha_is_local_label_name
87 PARAMS((bfd *, const char *));
88 static boolean elf64_alpha_find_nearest_line
89 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
90 const char **, unsigned int *));
92 #if defined(__STDC__) || defined(ALMOST_STDC)
93 struct alpha_elf_link_hash_entry;
96 static boolean elf64_alpha_output_extsym
97 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
99 static boolean elf64_alpha_can_merge_gots
100 PARAMS((bfd *, bfd *));
101 static void elf64_alpha_merge_gots
102 PARAMS((bfd *, bfd *));
103 static boolean elf64_alpha_calc_got_offsets_for_symbol
104 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
105 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
106 static boolean elf64_alpha_size_got_sections
107 PARAMS ((bfd *, struct bfd_link_info *));
108 static boolean elf64_alpha_always_size_sections
109 PARAMS ((bfd *, struct bfd_link_info *));
110 static boolean elf64_alpha_calc_dynrel_sizes
111 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
112 static boolean elf64_alpha_add_symbol_hook
113 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
114 const char **, flagword *, asection **, bfd_vma *));
115 static boolean elf64_alpha_check_relocs
116 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
117 const Elf_Internal_Rela *));
118 static boolean elf64_alpha_adjust_dynamic_symbol
119 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
120 static boolean elf64_alpha_size_dynamic_sections
121 PARAMS((bfd *, struct bfd_link_info *));
122 static boolean elf64_alpha_relocate_section
123 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
124 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
125 static boolean elf64_alpha_finish_dynamic_symbol
126 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
127 Elf_Internal_Sym *));
128 static boolean elf64_alpha_finish_dynamic_sections
129 PARAMS((bfd *, struct bfd_link_info *));
130 static boolean elf64_alpha_final_link
131 PARAMS((bfd *, struct bfd_link_info *));
132 static boolean elf64_alpha_merge_ind_symbols
133 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
134 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
135 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
137 struct alpha_elf_link_hash_entry
139 struct elf_link_hash_entry root;
141 /* External symbol information. */
144 /* Cumulative flags for all the .got entries. */
147 /* Contexts (LITUSE) in which a literal was referenced. */
148 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
149 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
150 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
151 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
153 /* Used to implement multiple .got subsections. */
154 struct alpha_elf_got_entry
156 struct alpha_elf_got_entry *next;
158 /* which .got subsection? */
161 /* the addend in effect for this entry. */
164 /* the .got offset for this entry. */
169 /* An additional flag. */
170 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
175 /* used to count non-got, non-plt relocations for delayed sizing
176 of relocation sections. */
177 struct alpha_elf_reloc_entry
179 struct alpha_elf_reloc_entry *next;
181 /* which .reloc section? */
184 /* what kind of relocation? */
187 /* how many did we find? */
192 /* Alpha ELF linker hash table. */
194 struct alpha_elf_link_hash_table
196 struct elf_link_hash_table root;
198 /* The head of a list of .got subsections linked through
199 alpha_elf_tdata(abfd)->got_link_next. */
203 /* Look up an entry in a Alpha ELF linker hash table. */
205 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
206 ((struct alpha_elf_link_hash_entry *) \
207 elf_link_hash_lookup (&(table)->root, (string), (create), \
210 /* Traverse a Alpha ELF linker hash table. */
212 #define alpha_elf_link_hash_traverse(table, func, info) \
213 (elf_link_hash_traverse \
215 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
218 /* Get the Alpha ELF linker hash table from a link_info structure. */
220 #define alpha_elf_hash_table(p) \
221 ((struct alpha_elf_link_hash_table *) ((p)->hash))
223 /* Get the object's symbols as our own entry type. */
225 #define alpha_elf_sym_hashes(abfd) \
226 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
228 /* Should we do dynamic things to this symbol? */
231 alpha_elf_dynamic_symbol_p (h, info)
232 struct elf_link_hash_entry *h;
233 struct bfd_link_info *info;
238 while (h->root.type == bfd_link_hash_indirect
239 || h->root.type == bfd_link_hash_warning)
240 h = (struct elf_link_hash_entry *) h->root.u.i.link;
242 if (h->dynindx == -1)
245 if (h->root.type == bfd_link_hash_undefweak
246 || h->root.type == bfd_link_hash_defweak)
249 switch (ELF_ST_VISIBILITY (h->other))
257 if (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
262 if ((info->shared && !info->symbolic)
263 || ((h->elf_link_hash_flags
264 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
265 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
271 /* Create an entry in a Alpha ELF linker hash table. */
273 static struct bfd_hash_entry *
274 elf64_alpha_link_hash_newfunc (entry, table, string)
275 struct bfd_hash_entry *entry;
276 struct bfd_hash_table *table;
279 struct alpha_elf_link_hash_entry *ret =
280 (struct alpha_elf_link_hash_entry *) entry;
282 /* Allocate the structure if it has not already been allocated by a
284 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
285 ret = ((struct alpha_elf_link_hash_entry *)
286 bfd_hash_allocate (table,
287 sizeof (struct alpha_elf_link_hash_entry)));
288 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
289 return (struct bfd_hash_entry *) ret;
291 /* Call the allocation method of the superclass. */
292 ret = ((struct alpha_elf_link_hash_entry *)
293 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
295 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
297 /* Set local fields. */
298 memset (&ret->esym, 0, sizeof (EXTR));
299 /* We use -2 as a marker to indicate that the information has
300 not been set. -1 means there is no associated ifd. */
303 ret->got_entries = NULL;
304 ret->reloc_entries = NULL;
307 return (struct bfd_hash_entry *) ret;
310 /* Create a Alpha ELF linker hash table. */
312 static struct bfd_link_hash_table *
313 elf64_alpha_bfd_link_hash_table_create (abfd)
316 struct alpha_elf_link_hash_table *ret;
318 ret = ((struct alpha_elf_link_hash_table *)
319 bfd_zalloc (abfd, sizeof (struct alpha_elf_link_hash_table)));
320 if (ret == (struct alpha_elf_link_hash_table *) NULL)
323 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
324 elf64_alpha_link_hash_newfunc))
326 bfd_release (abfd, ret);
330 return &ret->root.root;
333 /* We have some private fields hanging off of the elf_tdata structure. */
335 struct alpha_elf_obj_tdata
337 struct elf_obj_tdata root;
339 /* For every input file, these are the got entries for that object's
341 struct alpha_elf_got_entry ** local_got_entries;
343 /* For every input file, this is the object that owns the got that
344 this input file uses. */
347 /* For every got, this is a linked list through the objects using this got */
348 bfd *in_got_link_next;
350 /* For every got, this is a link to the next got subsegment. */
353 /* For every got, this is the section. */
356 /* For every got, this is it's total number of *entries*. */
357 int total_got_entries;
359 /* For every got, this is the sum of the number of *entries* required
360 to hold all of the member object's local got. */
361 int n_local_got_entries;
364 #define alpha_elf_tdata(abfd) \
365 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
368 elf64_alpha_mkobject (abfd)
371 abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
372 if (abfd->tdata.any == NULL)
378 elf64_alpha_object_p (abfd)
381 /* Allocate our special target data. */
382 struct alpha_elf_obj_tdata *new_tdata;
383 new_tdata = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
384 if (new_tdata == NULL)
386 new_tdata->root = *abfd->tdata.elf_obj_data;
387 abfd->tdata.any = new_tdata;
389 /* Set the right machine number for an Alpha ELF file. */
390 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
393 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
394 from smaller values. Start with zero, widen, *then* decrement. */
395 #define MINUS_ONE (((bfd_vma)0) - 1)
397 static reloc_howto_type elf64_alpha_howto_table[] =
399 HOWTO (R_ALPHA_NONE, /* type */
401 0, /* size (0 = byte, 1 = short, 2 = long) */
403 true, /* pc_relative */
405 complain_overflow_dont, /* complain_on_overflow */
406 elf64_alpha_reloc_nil, /* special_function */
408 false, /* partial_inplace */
411 true), /* pcrel_offset */
413 /* A 32 bit reference to a symbol. */
414 HOWTO (R_ALPHA_REFLONG, /* type */
416 2, /* size (0 = byte, 1 = short, 2 = long) */
418 false, /* pc_relative */
420 complain_overflow_bitfield, /* complain_on_overflow */
421 0, /* special_function */
422 "REFLONG", /* name */
423 false, /* partial_inplace */
424 0xffffffff, /* src_mask */
425 0xffffffff, /* dst_mask */
426 false), /* pcrel_offset */
428 /* A 64 bit reference to a symbol. */
429 HOWTO (R_ALPHA_REFQUAD, /* type */
431 4, /* size (0 = byte, 1 = short, 2 = long) */
433 false, /* pc_relative */
435 complain_overflow_bitfield, /* complain_on_overflow */
436 0, /* special_function */
437 "REFQUAD", /* name */
438 false, /* partial_inplace */
439 MINUS_ONE, /* src_mask */
440 MINUS_ONE, /* dst_mask */
441 false), /* pcrel_offset */
443 /* A 32 bit GP relative offset. This is just like REFLONG except
444 that when the value is used the value of the gp register will be
446 HOWTO (R_ALPHA_GPREL32, /* type */
448 2, /* size (0 = byte, 1 = short, 2 = long) */
450 false, /* pc_relative */
452 complain_overflow_bitfield, /* complain_on_overflow */
453 0, /* special_function */
454 "GPREL32", /* name */
455 false, /* partial_inplace */
456 0xffffffff, /* src_mask */
457 0xffffffff, /* dst_mask */
458 false), /* pcrel_offset */
460 /* Used for an instruction that refers to memory off the GP register. */
461 HOWTO (R_ALPHA_LITERAL, /* type */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
465 false, /* pc_relative */
467 complain_overflow_signed, /* complain_on_overflow */
468 0, /* special_function */
469 "ELF_LITERAL", /* name */
470 false, /* partial_inplace */
471 0xffff, /* src_mask */
472 0xffff, /* dst_mask */
473 false), /* pcrel_offset */
475 /* This reloc only appears immediately following an ELF_LITERAL reloc.
476 It identifies a use of the literal. The symbol index is special:
477 1 means the literal address is in the base register of a memory
478 format instruction; 2 means the literal address is in the byte
479 offset register of a byte-manipulation instruction; 3 means the
480 literal address is in the target register of a jsr instruction.
481 This does not actually do any relocation. */
482 HOWTO (R_ALPHA_LITUSE, /* type */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
486 false, /* pc_relative */
488 complain_overflow_dont, /* complain_on_overflow */
489 elf64_alpha_reloc_nil, /* special_function */
491 false, /* partial_inplace */
494 false), /* pcrel_offset */
496 /* Load the gp register. This is always used for a ldah instruction
497 which loads the upper 16 bits of the gp register. The symbol
498 index of the GPDISP instruction is an offset in bytes to the lda
499 instruction that loads the lower 16 bits. The value to use for
500 the relocation is the difference between the GP value and the
501 current location; the load will always be done against a register
502 holding the current address.
504 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
505 any offset is present in the instructions, it is an offset from
506 the register to the ldah instruction. This lets us avoid any
507 stupid hackery like inventing a gp value to do partial relocation
508 against. Also unlike ECOFF, we do the whole relocation off of
509 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
510 space consuming bit, that, since all the information was present
511 in the GPDISP_HI16 reloc. */
512 HOWTO (R_ALPHA_GPDISP, /* type */
514 2, /* size (0 = byte, 1 = short, 2 = long) */
516 false, /* pc_relative */
518 complain_overflow_dont, /* complain_on_overflow */
519 elf64_alpha_reloc_gpdisp, /* special_function */
521 false, /* partial_inplace */
522 0xffff, /* src_mask */
523 0xffff, /* dst_mask */
524 true), /* pcrel_offset */
526 /* A 21 bit branch. */
527 HOWTO (R_ALPHA_BRADDR, /* type */
529 2, /* size (0 = byte, 1 = short, 2 = long) */
531 true, /* pc_relative */
533 complain_overflow_signed, /* complain_on_overflow */
534 0, /* special_function */
536 false, /* partial_inplace */
537 0x1fffff, /* src_mask */
538 0x1fffff, /* dst_mask */
539 true), /* pcrel_offset */
541 /* A hint for a jump to a register. */
542 HOWTO (R_ALPHA_HINT, /* type */
544 2, /* size (0 = byte, 1 = short, 2 = long) */
546 true, /* pc_relative */
548 complain_overflow_dont, /* complain_on_overflow */
549 0, /* special_function */
551 false, /* partial_inplace */
552 0x3fff, /* src_mask */
553 0x3fff, /* dst_mask */
554 true), /* pcrel_offset */
556 /* 16 bit PC relative offset. */
557 HOWTO (R_ALPHA_SREL16, /* type */
559 1, /* size (0 = byte, 1 = short, 2 = long) */
561 true, /* pc_relative */
563 complain_overflow_signed, /* complain_on_overflow */
564 0, /* special_function */
566 false, /* partial_inplace */
567 0xffff, /* src_mask */
568 0xffff, /* dst_mask */
569 true), /* pcrel_offset */
571 /* 32 bit PC relative offset. */
572 HOWTO (R_ALPHA_SREL32, /* type */
574 2, /* size (0 = byte, 1 = short, 2 = long) */
576 true, /* pc_relative */
578 complain_overflow_signed, /* complain_on_overflow */
579 0, /* special_function */
581 false, /* partial_inplace */
582 0xffffffff, /* src_mask */
583 0xffffffff, /* dst_mask */
584 true), /* pcrel_offset */
586 /* A 64 bit PC relative offset. */
587 HOWTO (R_ALPHA_SREL64, /* type */
589 4, /* size (0 = byte, 1 = short, 2 = long) */
591 true, /* pc_relative */
593 complain_overflow_signed, /* complain_on_overflow */
594 0, /* special_function */
596 false, /* partial_inplace */
597 MINUS_ONE, /* src_mask */
598 MINUS_ONE, /* dst_mask */
599 true), /* pcrel_offset */
601 /* Push a value on the reloc evaluation stack. */
602 /* Not implemented -- it's dumb. */
603 HOWTO (R_ALPHA_OP_PUSH, /* type */
605 0, /* size (0 = byte, 1 = short, 2 = long) */
607 false, /* pc_relative */
609 complain_overflow_dont, /* complain_on_overflow */
610 elf64_alpha_reloc_bad, /* special_function */
611 "OP_PUSH", /* name */
612 false, /* partial_inplace */
615 false), /* pcrel_offset */
617 /* Store the value from the stack at the given address. Store it in
618 a bitfield of size r_size starting at bit position r_offset. */
619 /* Not implemented -- it's dumb. */
620 HOWTO (R_ALPHA_OP_STORE, /* type */
622 4, /* size (0 = byte, 1 = short, 2 = long) */
624 false, /* pc_relative */
626 complain_overflow_dont, /* complain_on_overflow */
627 elf64_alpha_reloc_bad, /* special_function */
628 "OP_STORE", /* name */
629 false, /* partial_inplace */
631 MINUS_ONE, /* dst_mask */
632 false), /* pcrel_offset */
634 /* Subtract the reloc address from the value on the top of the
636 /* Not implemented -- it's dumb. */
637 HOWTO (R_ALPHA_OP_PSUB, /* type */
639 0, /* size (0 = byte, 1 = short, 2 = long) */
641 false, /* pc_relative */
643 complain_overflow_dont, /* complain_on_overflow */
644 elf64_alpha_reloc_bad, /* special_function */
645 "OP_PSUB", /* name */
646 false, /* partial_inplace */
649 false), /* pcrel_offset */
651 /* Shift the value on the top of the relocation stack right by the
653 /* Not implemented -- it's dumb. */
654 HOWTO (R_ALPHA_OP_PRSHIFT, /* type */
656 0, /* size (0 = byte, 1 = short, 2 = long) */
658 false, /* pc_relative */
660 complain_overflow_dont, /* complain_on_overflow */
661 elf64_alpha_reloc_bad, /* special_function */
662 "OP_PRSHIFT", /* name */
663 false, /* partial_inplace */
666 false), /* pcrel_offset */
668 /* Change the value of GP used by +r_addend until the next GPVALUE or the
669 end of the input bfd. */
670 /* Not implemented -- it's dumb. */
671 HOWTO (R_ALPHA_GPVALUE,
673 0, /* size (0 = byte, 1 = short, 2 = long) */
675 false, /* pc_relative */
677 complain_overflow_dont, /* complain_on_overflow */
678 elf64_alpha_reloc_bad, /* special_function */
679 "GPVALUE", /* name */
680 false, /* partial_inplace */
683 false), /* pcrel_offset */
685 /* The high 16 bits of the displacement from GP to the target. */
686 HOWTO (R_ALPHA_GPRELHIGH,
688 2, /* size (0 = byte, 1 = short, 2 = long) */
690 false, /* pc_relative */
692 complain_overflow_signed, /* complain_on_overflow */
693 elf64_alpha_reloc_bad, /* special_function */
694 "GPRELHIGH", /* name */
695 false, /* partial_inplace */
696 0xffff, /* src_mask */
697 0xffff, /* dst_mask */
698 false), /* pcrel_offset */
700 /* The low 16 bits of the displacement from GP to the target. */
701 HOWTO (R_ALPHA_GPRELLOW,
703 2, /* size (0 = byte, 1 = short, 2 = long) */
705 false, /* pc_relative */
707 complain_overflow_dont, /* complain_on_overflow */
708 elf64_alpha_reloc_bad, /* special_function */
709 "GPRELLOW", /* name */
710 false, /* partial_inplace */
711 0xffff, /* src_mask */
712 0xffff, /* dst_mask */
713 false), /* pcrel_offset */
715 /* A 16-bit displacement from the GP to the target. */
716 /* XXX: Not implemented. */
717 HOWTO (R_ALPHA_IMMED_GP_16,
719 2, /* size (0 = byte, 1 = short, 2 = long) */
721 false, /* pc_relative */
723 complain_overflow_signed, /* complain_on_overflow */
724 0, /* special_function */
725 "IMMED_GP_16", /* name */
726 false, /* partial_inplace */
727 0xffff, /* src_mask */
728 0xffff, /* dst_mask */
729 false), /* pcrel_offset */
731 /* The high bits of a 32-bit displacement from the GP to the target; the
732 low bits are supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
733 /* XXX: Not implemented. */
734 HOWTO (R_ALPHA_IMMED_GP_HI32,
736 0, /* size (0 = byte, 1 = short, 2 = long) */
738 false, /* pc_relative */
740 complain_overflow_dont, /* complain_on_overflow */
741 elf64_alpha_reloc_bad, /* special_function */
742 "IMMED_GP_HI32", /* name */
743 false, /* partial_inplace */
746 false), /* pcrel_offset */
748 /* The high bits of a 32-bit displacement to the starting address of the
749 current section (the relocation target is ignored); the low bits are
750 supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
751 /* XXX: Not implemented. */
752 HOWTO (R_ALPHA_IMMED_SCN_HI32,
754 0, /* size (0 = byte, 1 = short, 2 = long) */
756 false, /* pc_relative */
758 complain_overflow_dont, /* complain_on_overflow */
759 elf64_alpha_reloc_bad, /* special_function */
760 "IMMED_SCN_HI32", /* name */
761 false, /* partial_inplace */
764 false), /* pcrel_offset */
766 /* The high bits of a 32-bit displacement from the previous br, bsr, jsr
767 or jmp insn (as tagged by a BRADDR or HINT reloc) to the target; the
768 low bits are supplied by subsequent R_ALPHA_IMMED_LO32 relocs. */
769 /* XXX: Not implemented. */
770 HOWTO (R_ALPHA_IMMED_BR_HI32,
772 0, /* size (0 = byte, 1 = short, 2 = long) */
774 false, /* pc_relative */
776 complain_overflow_dont, /* complain_on_overflow */
777 elf64_alpha_reloc_bad, /* special_function */
778 "IMMED_BR_HI32", /* name */
779 false, /* partial_inplace */
782 false), /* pcrel_offset */
784 /* The low 16 bits of a displacement calculated in a previous HI32 reloc. */
785 /* XXX: Not implemented. */
786 HOWTO (R_ALPHA_IMMED_LO32,
788 0, /* size (0 = byte, 1 = short, 2 = long) */
790 false, /* pc_relative */
792 complain_overflow_dont, /* complain_on_overflow */
793 elf64_alpha_reloc_bad, /* special_function */
794 "IMMED_LO32", /* name */
795 false, /* partial_inplace */
798 false), /* pcrel_offset */
800 /* Misc ELF relocations. */
802 /* A dynamic relocation to copy the target into our .dynbss section. */
803 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
804 is present because every other ELF has one, but should not be used
805 because .dynbss is an ugly thing. */
812 complain_overflow_dont,
813 bfd_elf_generic_reloc,
820 /* A dynamic relocation for a .got entry. */
821 HOWTO (R_ALPHA_GLOB_DAT,
827 complain_overflow_dont,
828 bfd_elf_generic_reloc,
835 /* A dynamic relocation for a .plt entry. */
836 HOWTO (R_ALPHA_JMP_SLOT,
842 complain_overflow_dont,
843 bfd_elf_generic_reloc,
850 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
851 HOWTO (R_ALPHA_RELATIVE,
857 complain_overflow_dont,
858 bfd_elf_generic_reloc,
866 /* A relocation function which doesn't do anything. */
868 static bfd_reloc_status_type
869 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
870 bfd *abfd ATTRIBUTE_UNUSED;
872 asymbol *sym ATTRIBUTE_UNUSED;
873 PTR data ATTRIBUTE_UNUSED;
876 char **error_message ATTRIBUTE_UNUSED;
879 reloc->address += sec->output_offset;
883 /* A relocation function used for an unsupported reloc. */
885 static bfd_reloc_status_type
886 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
887 bfd *abfd ATTRIBUTE_UNUSED;
889 asymbol *sym ATTRIBUTE_UNUSED;
890 PTR data ATTRIBUTE_UNUSED;
893 char **error_message ATTRIBUTE_UNUSED;
896 reloc->address += sec->output_offset;
897 return bfd_reloc_notsupported;
900 /* Do the work of the GPDISP relocation. */
902 static bfd_reloc_status_type
903 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
909 bfd_reloc_status_type ret = bfd_reloc_ok;
911 unsigned long i_ldah, i_lda;
913 i_ldah = bfd_get_32 (abfd, p_ldah);
914 i_lda = bfd_get_32 (abfd, p_lda);
916 /* Complain if the instructions are not correct. */
917 if (((i_ldah >> 26) & 0x3f) != 0x09
918 || ((i_lda >> 26) & 0x3f) != 0x08)
919 ret = bfd_reloc_dangerous;
921 /* Extract the user-supplied offset, mirroring the sign extensions
922 that the instructions perform. */
923 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
924 addend = (addend ^ 0x80008000) - 0x80008000;
928 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
929 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
930 ret = bfd_reloc_overflow;
932 /* compensate for the sign extension again. */
933 i_ldah = ((i_ldah & 0xffff0000)
934 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
935 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
937 bfd_put_32 (abfd, i_ldah, p_ldah);
938 bfd_put_32 (abfd, i_lda, p_lda);
943 /* The special function for the GPDISP reloc. */
945 static bfd_reloc_status_type
946 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
949 arelent *reloc_entry;
950 asymbol *sym ATTRIBUTE_UNUSED;
952 asection *input_section;
956 bfd_reloc_status_type ret;
957 bfd_vma gp, relocation;
958 bfd_byte *p_ldah, *p_lda;
960 /* Don't do anything if we're not doing a final link. */
963 reloc_entry->address += input_section->output_offset;
967 if (reloc_entry->address > input_section->_cooked_size ||
968 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
969 return bfd_reloc_outofrange;
971 /* The gp used in the portion of the output object to which this
972 input object belongs is cached on the input bfd. */
973 gp = _bfd_get_gp_value (abfd);
975 relocation = (input_section->output_section->vma
976 + input_section->output_offset
977 + reloc_entry->address);
979 p_ldah = (bfd_byte *) data + reloc_entry->address;
980 p_lda = p_ldah + reloc_entry->addend;
982 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
984 /* Complain if the instructions are not correct. */
985 if (ret == bfd_reloc_dangerous)
986 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
991 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
995 bfd_reloc_code_real_type bfd_reloc_val;
999 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1001 {BFD_RELOC_NONE, R_ALPHA_NONE},
1002 {BFD_RELOC_32, R_ALPHA_REFLONG},
1003 {BFD_RELOC_64, R_ALPHA_REFQUAD},
1004 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
1005 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
1006 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
1007 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
1008 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
1009 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
1010 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
1011 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
1012 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
1013 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
1015 /* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process
1016 the explicit !<reloc>!sequence relocations, and are mapped into the normal
1017 relocations at the end of processing. */
1018 {BFD_RELOC_ALPHA_USER_LITERAL, R_ALPHA_LITERAL},
1019 {BFD_RELOC_ALPHA_USER_LITUSE_BASE, R_ALPHA_LITUSE},
1020 {BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF, R_ALPHA_LITUSE},
1021 {BFD_RELOC_ALPHA_USER_LITUSE_JSR, R_ALPHA_LITUSE},
1022 {BFD_RELOC_ALPHA_USER_GPDISP, R_ALPHA_GPDISP},
1023 {BFD_RELOC_ALPHA_USER_GPRELHIGH, R_ALPHA_GPRELHIGH},
1024 {BFD_RELOC_ALPHA_USER_GPRELLOW, R_ALPHA_GPRELLOW},
1027 /* Given a BFD reloc type, return a HOWTO structure. */
1029 static reloc_howto_type *
1030 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
1031 bfd *abfd ATTRIBUTE_UNUSED;
1032 bfd_reloc_code_real_type code;
1034 const struct elf_reloc_map *i, *e;
1035 i = e = elf64_alpha_reloc_map;
1036 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1039 if (i->bfd_reloc_val == code)
1040 return &elf64_alpha_howto_table[i->elf_reloc_val];
1045 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1048 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
1049 bfd *abfd ATTRIBUTE_UNUSED;
1051 Elf64_Internal_Rela *dst;
1055 r_type = ELF64_R_TYPE(dst->r_info);
1056 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
1057 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1060 /* These functions do relaxation for Alpha ELF.
1062 Currently I'm only handling what I can do with existing compiler
1063 and assembler support, which means no instructions are removed,
1064 though some may be nopped. At this time GCC does not emit enough
1065 information to do all of the relaxing that is possible. It will
1066 take some not small amount of work for that to happen.
1068 There are a couple of interesting papers that I once read on this
1069 subject, that I cannot find references to at the moment, that
1070 related to Alpha in particular. They are by David Wall, then of
1074 #define OP_LDAH 0x09
1075 #define INSN_JSR 0x68004000
1076 #define INSN_JSR_MASK 0xfc00c000
1080 #define INSN_UNOP 0x2fe00000
1082 struct alpha_relax_info
1087 Elf_Internal_Rela *relocs, *relend;
1088 struct bfd_link_info *link_info;
1089 boolean changed_contents;
1090 boolean changed_relocs;
1094 struct alpha_elf_link_hash_entry *h;
1095 struct alpha_elf_got_entry *gotent;
1096 unsigned char other;
1099 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
1100 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1101 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
1103 static boolean elf64_alpha_relax_without_lituse
1104 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1105 Elf_Internal_Rela *irel));
1107 static bfd_vma elf64_alpha_relax_opt_call
1108 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
1110 static boolean elf64_alpha_relax_section
1111 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
1114 static Elf_Internal_Rela *
1115 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
1116 Elf_Internal_Rela *rel, *relend;
1120 while (rel < relend)
1122 if (rel->r_offset == offset && ELF64_R_TYPE (rel->r_info) == type)
1129 static Elf_Internal_Rela *
1130 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1131 struct alpha_relax_info *info;
1133 Elf_Internal_Rela *irel, *irelend;
1135 Elf_Internal_Rela *urel;
1136 int flags, count, i;
1137 bfd_signed_vma disp;
1140 boolean lit_reused = false;
1141 boolean all_optimized = true;
1142 unsigned int lit_insn;
1144 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1145 if (lit_insn >> 26 != OP_LDQ)
1147 ((*_bfd_error_handler)
1148 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1149 bfd_get_filename (info->abfd), info->sec->name,
1150 (unsigned long)irel->r_offset));
1154 /* Summarize how this particular LITERAL is used. */
1155 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1157 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1159 if (urel->r_addend >= 0 && urel->r_addend <= 3)
1160 flags |= 1 << urel->r_addend;
1163 /* A little preparation for the loop... */
1164 disp = symval - info->gp;
1166 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1170 bfd_signed_vma xdisp;
1172 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1174 switch (urel->r_addend)
1176 default: /* 0 = ADDRESS FORMAT */
1177 /* This type is really just a placeholder to note that all
1178 uses cannot be optimized, but to still allow some. */
1179 all_optimized = false;
1182 case 1: /* MEM FORMAT */
1183 /* We can always optimize 16-bit displacements. */
1185 /* Extract the displacement from the instruction, sign-extending
1186 it if necessary, then test whether it is within 16 or 32 bits
1187 displacement from GP. */
1188 insn_disp = insn & 0x0000ffff;
1189 if (insn_disp & 0x00008000)
1190 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1192 xdisp = disp + insn_disp;
1193 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1194 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1198 /* Take the op code and dest from this insn, take the base
1199 register from the literal insn. Leave the offset alone. */
1200 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1201 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1203 urel->r_addend = irel->r_addend;
1204 info->changed_relocs = true;
1206 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1207 info->changed_contents = true;
1210 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1211 else if (fits32 && !(flags & ~6))
1213 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1215 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1217 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1218 bfd_put_32 (info->abfd, lit_insn,
1219 info->contents + irel->r_offset);
1221 info->changed_contents = true;
1223 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1225 urel->r_addend = irel->r_addend;
1226 info->changed_relocs = true;
1229 all_optimized = false;
1232 case 2: /* BYTE OFFSET FORMAT */
1233 /* We can always optimize byte instructions. */
1235 /* FIXME: sanity check the insn for byte op. Check that the
1236 literal dest reg is indeed Rb in the byte insn. */
1238 insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
1240 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1242 info->changed_relocs = true;
1244 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1245 info->changed_contents = true;
1248 case 3: /* CALL FORMAT */
1250 /* If not zero, place to jump without needing pv. */
1251 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1252 bfd_vma org = (info->sec->output_section->vma
1253 + info->sec->output_offset
1254 + urel->r_offset + 4);
1255 bfd_signed_vma odisp;
1257 odisp = (optdest ? optdest : symval) - org;
1258 if (odisp >= -0x400000 && odisp < 0x400000)
1260 Elf_Internal_Rela *xrel;
1262 /* Preserve branch prediction call stack when possible. */
1263 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1264 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1266 insn = (OP_BR << 26) | (insn & 0x03e00000);
1268 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1270 urel->r_addend = irel->r_addend;
1273 urel->r_addend += optdest - symval;
1275 all_optimized = false;
1277 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1279 /* Kill any HINT reloc that might exist for this insn. */
1280 xrel = (elf64_alpha_find_reloc_at_ofs
1281 (info->relocs, info->relend, urel->r_offset,
1284 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1286 info->changed_contents = true;
1287 info->changed_relocs = true;
1290 all_optimized = false;
1292 /* ??? If target gp == current gp we can eliminate the gp reload.
1293 This does depend on every place a gp could be reloaded will
1294 be, which currently happens for all code produced by gcc, but
1295 not necessarily by hand-coded assembly, or if sibling calls
1298 Perhaps conditionalize this on a flag being set in the target
1299 object file's header, and have gcc set it? */
1305 /* If all cases were optimized, we can reduce the use count on this
1306 got entry by one, possibly eliminating it. */
1309 info->gotent->use_count -= 1;
1310 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1312 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1314 /* If the literal instruction is no longer needed (it may have been
1315 reused. We can eliminate it.
1316 ??? For now, I don't want to deal with compacting the section,
1317 so just nop it out. */
1320 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1321 info->changed_relocs = true;
1323 bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
1324 info->changed_contents = true;
1328 return irel + count;
1332 elf64_alpha_relax_opt_call (info, symval)
1333 struct alpha_relax_info *info;
1336 /* If the function has the same gp, and we can identify that the
1337 function does not use its function pointer, we can eliminate the
1340 /* If the symbol is marked NOPV, we are being told the function never
1341 needs its procedure value. */
1342 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1345 /* If the symbol is marked STD_GP, we are being told the function does
1346 a normal ldgp in the first two words. */
1347 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1350 /* Otherwise, we may be able to identify a GP load in the first two
1351 words, which we can then skip. */
1354 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1357 /* Load the relocations from the section that the target symbol is in. */
1358 if (info->sec == info->tsec)
1360 tsec_relocs = info->relocs;
1361 tsec_relend = info->relend;
1366 tsec_relocs = (_bfd_elf64_link_read_relocs
1367 (info->abfd, info->tsec, (PTR) NULL,
1368 (Elf_Internal_Rela *) NULL,
1369 info->link_info->keep_memory));
1370 if (tsec_relocs == NULL)
1372 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1373 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1376 /* Recover the symbol's offset within the section. */
1377 ofs = (symval - info->tsec->output_section->vma
1378 - info->tsec->output_offset);
1380 /* Look for a GPDISP reloc. */
1381 gpdisp = (elf64_alpha_find_reloc_at_ofs
1382 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1384 if (!gpdisp || gpdisp->r_addend != 4)
1394 /* We've now determined that we can skip an initial gp load. Verify
1395 that the call and the target use the same gp. */
1396 if (info->link_info->hash->creator != info->tsec->owner->xvec
1397 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1404 elf64_alpha_relax_without_lituse (info, symval, irel)
1405 struct alpha_relax_info *info;
1407 Elf_Internal_Rela *irel;
1410 bfd_signed_vma disp;
1412 /* Get the instruction. */
1413 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1415 if (insn >> 26 != OP_LDQ)
1417 ((*_bfd_error_handler)
1418 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1419 bfd_get_filename (info->abfd), info->sec->name,
1420 (unsigned long) irel->r_offset));
1424 /* So we aren't told much. Do what we can with the address load and
1425 fake the rest. All of the optimizations here require that the
1426 offset from the GP fit in 16 bits. */
1428 disp = symval - info->gp;
1429 if (disp < -0x8000 || disp >= 0x8000)
1432 /* On the LITERAL instruction itself, consider exchanging
1433 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1435 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1436 bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
1437 info->changed_contents = true;
1439 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELLOW);
1440 info->changed_relocs = true;
1442 /* Reduce the use count on this got entry by one, possibly
1444 info->gotent->use_count -= 1;
1445 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1447 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1449 /* ??? Search forward through this basic block looking for insns
1450 that use the target register. Stop after an insn modifying the
1451 register is seen, or after a branch or call.
1453 Any such memory load insn may be substituted by a load directly
1454 off the GP. This allows the memory load insn to be issued before
1455 the calculated GP register would otherwise be ready.
1457 Any such jsr insn can be replaced by a bsr if it is in range.
1459 This would mean that we'd have to _add_ relocations, the pain of
1460 which gives one pause. */
1466 elf64_alpha_relax_section (abfd, sec, link_info, again)
1469 struct bfd_link_info *link_info;
1472 Elf_Internal_Shdr *symtab_hdr;
1473 Elf_Internal_Rela *internal_relocs;
1474 Elf_Internal_Rela *free_relocs = NULL;
1475 Elf_Internal_Rela *irel, *irelend;
1476 bfd_byte *free_contents = NULL;
1477 Elf64_External_Sym *extsyms = NULL;
1478 Elf64_External_Sym *free_extsyms = NULL;
1479 struct alpha_elf_got_entry **local_got_entries;
1480 struct alpha_relax_info info;
1482 /* We are not currently changing any sizes, so only one pass. */
1485 if (link_info->relocateable
1486 || (sec->flags & SEC_RELOC) == 0
1487 || sec->reloc_count == 0)
1490 /* If this is the first time we have been called for this section,
1491 initialize the cooked size. */
1492 if (sec->_cooked_size == 0)
1493 sec->_cooked_size = sec->_raw_size;
1495 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1496 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1498 /* Load the relocations for this section. */
1499 internal_relocs = (_bfd_elf64_link_read_relocs
1500 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1501 link_info->keep_memory));
1502 if (internal_relocs == NULL)
1504 if (! link_info->keep_memory)
1505 free_relocs = internal_relocs;
1507 memset(&info, 0, sizeof (info));
1510 info.link_info = link_info;
1511 info.relocs = internal_relocs;
1512 info.relend = irelend = internal_relocs + sec->reloc_count;
1514 /* Find the GP for this object. */
1515 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1518 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1519 info.gp = _bfd_get_gp_value (info.gotobj);
1522 info.gp = (sgot->output_section->vma
1523 + sgot->output_offset
1525 _bfd_set_gp_value (info.gotobj, info.gp);
1529 for (irel = internal_relocs; irel < irelend; irel++)
1532 Elf_Internal_Sym isym;
1533 struct alpha_elf_got_entry *gotent;
1535 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1538 /* Get the section contents. */
1539 if (info.contents == NULL)
1541 if (elf_section_data (sec)->this_hdr.contents != NULL)
1542 info.contents = elf_section_data (sec)->this_hdr.contents;
1545 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1546 if (info.contents == NULL)
1548 free_contents = info.contents;
1550 if (! bfd_get_section_contents (abfd, sec, info.contents,
1551 (file_ptr) 0, sec->_raw_size))
1556 /* Read this BFD's symbols if we haven't done so already. */
1557 if (extsyms == NULL)
1559 if (symtab_hdr->contents != NULL)
1560 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1563 extsyms = ((Elf64_External_Sym *)
1564 bfd_malloc (symtab_hdr->sh_size));
1565 if (extsyms == NULL)
1567 free_extsyms = extsyms;
1568 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1569 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1570 != symtab_hdr->sh_size))
1575 /* Get the value of the symbol referred to by the reloc. */
1576 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1578 /* A local symbol. */
1579 bfd_elf64_swap_symbol_in (abfd,
1580 extsyms + ELF64_R_SYM (irel->r_info),
1582 if (isym.st_shndx == SHN_UNDEF)
1583 info.tsec = bfd_und_section_ptr;
1584 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1585 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1586 else if (isym.st_shndx == SHN_ABS)
1587 info.tsec = bfd_abs_section_ptr;
1588 else if (isym.st_shndx == SHN_COMMON)
1589 info.tsec = bfd_com_section_ptr;
1591 continue; /* who knows. */
1594 info.other = isym.st_other;
1595 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1596 symval = isym.st_value;
1601 struct alpha_elf_link_hash_entry *h;
1603 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1604 h = alpha_elf_sym_hashes (abfd)[indx];
1605 BFD_ASSERT (h != NULL);
1607 while (h->root.root.type == bfd_link_hash_indirect
1608 || h->root.root.type == bfd_link_hash_warning)
1609 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1611 /* We can't do anthing with undefined or dynamic symbols. */
1612 if (h->root.root.type == bfd_link_hash_undefined
1613 || h->root.root.type == bfd_link_hash_undefweak
1614 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1618 info.gotent = gotent;
1619 info.tsec = h->root.root.u.def.section;
1620 info.other = h->root.other;
1621 gotent = h->got_entries;
1622 symval = h->root.root.u.def.value;
1625 /* Search for the got entry to be used by this relocation. */
1626 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1627 gotent = gotent->next;
1628 info.gotent = gotent;
1630 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1631 symval += irel->r_addend;
1633 BFD_ASSERT(info.gotent != NULL);
1635 /* If there exist LITUSE relocations immediately following, this
1636 opens up all sorts of interesting optimizations, because we
1637 now know every location that this address load is used. */
1639 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1641 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1647 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1652 if (!elf64_alpha_size_got_sections (abfd, link_info))
1655 if (info.changed_relocs)
1657 elf_section_data (sec)->relocs = internal_relocs;
1659 else if (free_relocs != NULL)
1664 if (info.changed_contents)
1666 elf_section_data (sec)->this_hdr.contents = info.contents;
1668 else if (free_contents != NULL)
1670 if (! link_info->keep_memory)
1671 free (free_contents);
1674 /* Cache the section contents for elf_link_input_bfd. */
1675 elf_section_data (sec)->this_hdr.contents = info.contents;
1679 if (free_extsyms != NULL)
1681 if (! link_info->keep_memory)
1682 free (free_extsyms);
1685 /* Cache the symbols for elf_link_input_bfd. */
1686 symtab_hdr->contents = extsyms;
1690 *again = info.changed_contents || info.changed_relocs;
1695 if (free_relocs != NULL)
1697 if (free_contents != NULL)
1698 free (free_contents);
1699 if (free_extsyms != NULL)
1700 free (free_extsyms);
1705 #define PLT_HEADER_SIZE 32
1706 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1707 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1708 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1709 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1711 #define PLT_ENTRY_SIZE 12
1712 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1713 #define PLT_ENTRY_WORD2 0
1714 #define PLT_ENTRY_WORD3 0
1716 #define MAX_GOT_ENTRIES (64*1024 / 8)
1718 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1720 /* Handle an Alpha specific section when reading an object file. This
1721 is called when elfcode.h finds a section with an unknown type.
1722 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1726 elf64_alpha_section_from_shdr (abfd, hdr, name)
1728 Elf64_Internal_Shdr *hdr;
1733 /* There ought to be a place to keep ELF backend specific flags, but
1734 at the moment there isn't one. We just keep track of the
1735 sections by their name, instead. Fortunately, the ABI gives
1736 suggested names for all the MIPS specific sections, so we will
1737 probably get away with this. */
1738 switch (hdr->sh_type)
1740 case SHT_ALPHA_DEBUG:
1741 if (strcmp (name, ".mdebug") != 0)
1744 #ifdef ERIC_neverdef
1745 case SHT_ALPHA_REGINFO:
1746 if (strcmp (name, ".reginfo") != 0
1747 || hdr->sh_size != sizeof (Elf64_External_RegInfo))
1755 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1757 newsect = hdr->bfd_section;
1759 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1761 if (! bfd_set_section_flags (abfd, newsect,
1762 (bfd_get_section_flags (abfd, newsect)
1767 #ifdef ERIC_neverdef
1768 /* For a .reginfo section, set the gp value in the tdata information
1769 from the contents of this section. We need the gp value while
1770 processing relocs, so we just get it now. */
1771 if (hdr->sh_type == SHT_ALPHA_REGINFO)
1773 Elf64_External_RegInfo ext;
1776 if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
1777 (file_ptr) 0, sizeof ext))
1779 bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
1780 elf_gp (abfd) = s.ri_gp_value;
1787 /* Set the correct type for an Alpha ELF section. We do this by the
1788 section name, which is a hack, but ought to work. */
1791 elf64_alpha_fake_sections (abfd, hdr, sec)
1793 Elf64_Internal_Shdr *hdr;
1796 register const char *name;
1798 name = bfd_get_section_name (abfd, sec);
1800 if (strcmp (name, ".mdebug") == 0)
1802 hdr->sh_type = SHT_ALPHA_DEBUG;
1803 /* In a shared object on Irix 5.3, the .mdebug section has an
1804 entsize of 0. FIXME: Does this matter? */
1805 if ((abfd->flags & DYNAMIC) != 0 )
1806 hdr->sh_entsize = 0;
1808 hdr->sh_entsize = 1;
1810 #ifdef ERIC_neverdef
1811 else if (strcmp (name, ".reginfo") == 0)
1813 hdr->sh_type = SHT_ALPHA_REGINFO;
1814 /* In a shared object on Irix 5.3, the .reginfo section has an
1815 entsize of 0x18. FIXME: Does this matter? */
1816 if ((abfd->flags & DYNAMIC) != 0)
1817 hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
1819 hdr->sh_entsize = 1;
1821 /* Force the section size to the correct value, even if the
1822 linker thinks it is larger. The link routine below will only
1823 write out this much data for .reginfo. */
1824 hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
1826 else if (strcmp (name, ".hash") == 0
1827 || strcmp (name, ".dynamic") == 0
1828 || strcmp (name, ".dynstr") == 0)
1830 hdr->sh_entsize = 0;
1831 hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
1834 else if (strcmp (name, ".sdata") == 0
1835 || strcmp (name, ".sbss") == 0
1836 || strcmp (name, ".lit4") == 0
1837 || strcmp (name, ".lit8") == 0)
1838 hdr->sh_flags |= SHF_ALPHA_GPREL;
1843 /* Hook called by the linker routine which adds symbols from an object
1844 file. We use it to put .comm items in .sbss, and not .bss. */
1847 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1849 struct bfd_link_info *info;
1850 const Elf_Internal_Sym *sym;
1851 const char **namep ATTRIBUTE_UNUSED;
1852 flagword *flagsp ATTRIBUTE_UNUSED;
1856 if (sym->st_shndx == SHN_COMMON
1857 && !info->relocateable
1858 && sym->st_size <= bfd_get_gp_size (abfd))
1860 /* Common symbols less than or equal to -G nn bytes are
1861 automatically put into .sbss. */
1863 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1867 scomm = bfd_make_section (abfd, ".scommon");
1869 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1871 | SEC_LINKER_CREATED)))
1876 *valp = sym->st_size;
1882 /* Create the .got section. */
1885 elf64_alpha_create_got_section(abfd, info)
1887 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1891 if (bfd_get_section_by_name (abfd, ".got"))
1894 s = bfd_make_section (abfd, ".got");
1896 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1899 | SEC_LINKER_CREATED))
1900 || !bfd_set_section_alignment (abfd, s, 3))
1903 alpha_elf_tdata (abfd)->got = s;
1908 /* Create all the dynamic sections. */
1911 elf64_alpha_create_dynamic_sections (abfd, info)
1913 struct bfd_link_info *info;
1916 struct elf_link_hash_entry *h;
1918 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1920 s = bfd_make_section (abfd, ".plt");
1922 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1925 | SEC_LINKER_CREATED
1927 || ! bfd_set_section_alignment (abfd, s, 3))
1930 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1933 if (! (_bfd_generic_link_add_one_symbol
1934 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1935 (bfd_vma) 0, (const char *) NULL, false,
1936 get_elf_backend_data (abfd)->collect,
1937 (struct bfd_link_hash_entry **) &h)))
1939 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1940 h->type = STT_OBJECT;
1943 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1946 s = bfd_make_section (abfd, ".rela.plt");
1948 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1951 | SEC_LINKER_CREATED
1953 || ! bfd_set_section_alignment (abfd, s, 3))
1956 /* We may or may not have created a .got section for this object, but
1957 we definitely havn't done the rest of the work. */
1959 if (!elf64_alpha_create_got_section (abfd, info))
1962 s = bfd_make_section(abfd, ".rela.got");
1964 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1967 | SEC_LINKER_CREATED
1969 || !bfd_set_section_alignment (abfd, s, 3))
1972 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1973 dynobj's .got section. We don't do this in the linker script
1974 because we don't want to define the symbol if we are not creating
1975 a global offset table. */
1977 if (!(_bfd_generic_link_add_one_symbol
1978 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1979 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1980 false, get_elf_backend_data (abfd)->collect,
1981 (struct bfd_link_hash_entry **) &h)))
1983 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1984 h->type = STT_OBJECT;
1987 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1990 elf_hash_table (info)->hgot = h;
1995 /* Read ECOFF debugging information from a .mdebug section into a
1996 ecoff_debug_info structure. */
1999 elf64_alpha_read_ecoff_info (abfd, section, debug)
2002 struct ecoff_debug_info *debug;
2005 const struct ecoff_debug_swap *swap;
2006 char *ext_hdr = NULL;
2008 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2009 memset (debug, 0, sizeof (*debug));
2011 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
2012 if (ext_hdr == NULL && swap->external_hdr_size != 0)
2015 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
2016 swap->external_hdr_size)
2020 symhdr = &debug->symbolic_header;
2021 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
2023 /* The symbolic header contains absolute file offsets and sizes to
2025 #define READ(ptr, offset, count, size, type) \
2026 if (symhdr->count == 0) \
2027 debug->ptr = NULL; \
2030 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
2031 if (debug->ptr == NULL) \
2032 goto error_return; \
2033 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2034 || (bfd_read (debug->ptr, size, symhdr->count, \
2035 abfd) != size * symhdr->count)) \
2036 goto error_return; \
2039 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
2040 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
2041 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
2042 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
2043 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2044 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2046 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2047 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2048 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2049 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2050 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2054 debug->adjust = NULL;
2059 if (ext_hdr != NULL)
2061 if (debug->line != NULL)
2063 if (debug->external_dnr != NULL)
2064 free (debug->external_dnr);
2065 if (debug->external_pdr != NULL)
2066 free (debug->external_pdr);
2067 if (debug->external_sym != NULL)
2068 free (debug->external_sym);
2069 if (debug->external_opt != NULL)
2070 free (debug->external_opt);
2071 if (debug->external_aux != NULL)
2072 free (debug->external_aux);
2073 if (debug->ss != NULL)
2075 if (debug->ssext != NULL)
2076 free (debug->ssext);
2077 if (debug->external_fdr != NULL)
2078 free (debug->external_fdr);
2079 if (debug->external_rfd != NULL)
2080 free (debug->external_rfd);
2081 if (debug->external_ext != NULL)
2082 free (debug->external_ext);
2086 /* Alpha ELF local labels start with '$'. */
2089 elf64_alpha_is_local_label_name (abfd, name)
2090 bfd *abfd ATTRIBUTE_UNUSED;
2093 return name[0] == '$';
2096 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2097 routine in order to handle the ECOFF debugging information. We
2098 still call this mips_elf_find_line because of the slot
2099 find_line_info in elf_obj_tdata is declared that way. */
2101 struct mips_elf_find_line
2103 struct ecoff_debug_info d;
2104 struct ecoff_find_line i;
2108 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2109 functionname_ptr, line_ptr)
2114 const char **filename_ptr;
2115 const char **functionname_ptr;
2116 unsigned int *line_ptr;
2120 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2121 filename_ptr, functionname_ptr,
2123 &elf_tdata (abfd)->dwarf2_find_line_info))
2126 msec = bfd_get_section_by_name (abfd, ".mdebug");
2130 struct mips_elf_find_line *fi;
2131 const struct ecoff_debug_swap * const swap =
2132 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2134 /* If we are called during a link, alpha_elf_final_link may have
2135 cleared the SEC_HAS_CONTENTS field. We force it back on here
2136 if appropriate (which it normally will be). */
2137 origflags = msec->flags;
2138 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2139 msec->flags |= SEC_HAS_CONTENTS;
2141 fi = elf_tdata (abfd)->find_line_info;
2144 bfd_size_type external_fdr_size;
2147 struct fdr *fdr_ptr;
2149 fi = ((struct mips_elf_find_line *)
2150 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2153 msec->flags = origflags;
2157 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2159 msec->flags = origflags;
2163 /* Swap in the FDR information. */
2164 fi->d.fdr = ((struct fdr *)
2166 (fi->d.symbolic_header.ifdMax *
2167 sizeof (struct fdr))));
2168 if (fi->d.fdr == NULL)
2170 msec->flags = origflags;
2173 external_fdr_size = swap->external_fdr_size;
2174 fdr_ptr = fi->d.fdr;
2175 fraw_src = (char *) fi->d.external_fdr;
2176 fraw_end = (fraw_src
2177 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2178 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2179 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2181 elf_tdata (abfd)->find_line_info = fi;
2183 /* Note that we don't bother to ever free this information.
2184 find_nearest_line is either called all the time, as in
2185 objdump -l, so the information should be saved, or it is
2186 rarely called, as in ld error messages, so the memory
2187 wasted is unimportant. Still, it would probably be a
2188 good idea for free_cached_info to throw it away. */
2191 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2192 &fi->i, filename_ptr, functionname_ptr,
2195 msec->flags = origflags;
2199 msec->flags = origflags;
2202 /* Fall back on the generic ELF find_nearest_line routine. */
2204 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2205 filename_ptr, functionname_ptr,
2209 /* Structure used to pass information to alpha_elf_output_extsym. */
2214 struct bfd_link_info *info;
2215 struct ecoff_debug_info *debug;
2216 const struct ecoff_debug_swap *swap;
2221 elf64_alpha_output_extsym (h, data)
2222 struct alpha_elf_link_hash_entry *h;
2225 struct extsym_info *einfo = (struct extsym_info *) data;
2227 asection *sec, *output_section;
2229 if (h->root.indx == -2)
2231 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2232 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2233 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2234 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2236 else if (einfo->info->strip == strip_all
2237 || (einfo->info->strip == strip_some
2238 && bfd_hash_lookup (einfo->info->keep_hash,
2239 h->root.root.root.string,
2240 false, false) == NULL))
2248 if (h->esym.ifd == -2)
2251 h->esym.cobol_main = 0;
2252 h->esym.weakext = 0;
2253 h->esym.reserved = 0;
2254 h->esym.ifd = ifdNil;
2255 h->esym.asym.value = 0;
2256 h->esym.asym.st = stGlobal;
2258 if (h->root.root.type != bfd_link_hash_defined
2259 && h->root.root.type != bfd_link_hash_defweak)
2260 h->esym.asym.sc = scAbs;
2265 sec = h->root.root.u.def.section;
2266 output_section = sec->output_section;
2268 /* When making a shared library and symbol h is the one from
2269 the another shared library, OUTPUT_SECTION may be null. */
2270 if (output_section == NULL)
2271 h->esym.asym.sc = scUndefined;
2274 name = bfd_section_name (output_section->owner, output_section);
2276 if (strcmp (name, ".text") == 0)
2277 h->esym.asym.sc = scText;
2278 else if (strcmp (name, ".data") == 0)
2279 h->esym.asym.sc = scData;
2280 else if (strcmp (name, ".sdata") == 0)
2281 h->esym.asym.sc = scSData;
2282 else if (strcmp (name, ".rodata") == 0
2283 || strcmp (name, ".rdata") == 0)
2284 h->esym.asym.sc = scRData;
2285 else if (strcmp (name, ".bss") == 0)
2286 h->esym.asym.sc = scBss;
2287 else if (strcmp (name, ".sbss") == 0)
2288 h->esym.asym.sc = scSBss;
2289 else if (strcmp (name, ".init") == 0)
2290 h->esym.asym.sc = scInit;
2291 else if (strcmp (name, ".fini") == 0)
2292 h->esym.asym.sc = scFini;
2294 h->esym.asym.sc = scAbs;
2298 h->esym.asym.reserved = 0;
2299 h->esym.asym.index = indexNil;
2302 if (h->root.root.type == bfd_link_hash_common)
2303 h->esym.asym.value = h->root.root.u.c.size;
2304 else if (h->root.root.type == bfd_link_hash_defined
2305 || h->root.root.type == bfd_link_hash_defweak)
2307 if (h->esym.asym.sc == scCommon)
2308 h->esym.asym.sc = scBss;
2309 else if (h->esym.asym.sc == scSCommon)
2310 h->esym.asym.sc = scSBss;
2312 sec = h->root.root.u.def.section;
2313 output_section = sec->output_section;
2314 if (output_section != NULL)
2315 h->esym.asym.value = (h->root.root.u.def.value
2316 + sec->output_offset
2317 + output_section->vma);
2319 h->esym.asym.value = 0;
2321 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2323 /* Set type and value for a symbol with a function stub. */
2324 h->esym.asym.st = stProc;
2325 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2327 h->esym.asym.value = 0;
2330 output_section = sec->output_section;
2331 if (output_section != NULL)
2332 h->esym.asym.value = (h->root.plt.offset
2333 + sec->output_offset
2334 + output_section->vma);
2336 h->esym.asym.value = 0;
2343 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2344 h->root.root.root.string,
2347 einfo->failed = true;
2354 /* FIXME: Create a runtime procedure table from the .mdebug section.
2357 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2360 struct bfd_link_info *info;
2362 struct ecoff_debug_info *debug;
2365 /* Handle dynamic relocations when doing an Alpha ELF link. */
2368 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2370 struct bfd_link_info *info;
2372 const Elf_Internal_Rela *relocs;
2376 const char *rel_sec_name;
2377 Elf_Internal_Shdr *symtab_hdr;
2378 struct alpha_elf_link_hash_entry **sym_hashes;
2379 struct alpha_elf_got_entry **local_got_entries;
2380 const Elf_Internal_Rela *rel, *relend;
2383 if (info->relocateable)
2386 dynobj = elf_hash_table(info)->dynobj;
2388 elf_hash_table(info)->dynobj = dynobj = abfd;
2391 rel_sec_name = NULL;
2392 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2393 sym_hashes = alpha_elf_sym_hashes(abfd);
2394 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2397 relend = relocs + sec->reloc_count;
2398 for (rel = relocs; rel < relend; ++rel)
2400 unsigned long r_symndx, r_type;
2401 struct alpha_elf_link_hash_entry *h;
2403 r_symndx = ELF64_R_SYM (rel->r_info);
2404 if (r_symndx < symtab_hdr->sh_info)
2408 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2410 while (h->root.root.type == bfd_link_hash_indirect
2411 || h->root.root.type == bfd_link_hash_warning)
2412 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2414 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2416 r_type = ELF64_R_TYPE (rel->r_info);
2420 case R_ALPHA_LITERAL:
2422 struct alpha_elf_got_entry *gotent;
2427 /* Search for and possibly create a got entry. */
2428 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2429 if (gotent->gotobj == abfd &&
2430 gotent->addend == rel->r_addend)
2435 gotent = ((struct alpha_elf_got_entry *)
2437 sizeof (struct alpha_elf_got_entry)));
2441 gotent->gotobj = abfd;
2442 gotent->addend = rel->r_addend;
2443 gotent->got_offset = -1;
2445 gotent->use_count = 1;
2447 gotent->next = h->got_entries;
2448 h->got_entries = gotent;
2450 alpha_elf_tdata (abfd)->total_got_entries++;
2453 gotent->use_count += 1;
2457 /* This is a local .got entry -- record for merge. */
2458 if (!local_got_entries)
2461 size = (symtab_hdr->sh_info
2462 * sizeof (struct alpha_elf_got_entry *));
2464 local_got_entries = ((struct alpha_elf_got_entry **)
2465 bfd_alloc (abfd, size));
2466 if (!local_got_entries)
2469 memset (local_got_entries, 0, size);
2470 alpha_elf_tdata (abfd)->local_got_entries =
2474 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2475 gotent != NULL && gotent->addend != rel->r_addend;
2476 gotent = gotent->next)
2480 gotent = ((struct alpha_elf_got_entry *)
2482 sizeof (struct alpha_elf_got_entry)));
2486 gotent->gotobj = abfd;
2487 gotent->addend = rel->r_addend;
2488 gotent->got_offset = -1;
2490 gotent->use_count = 1;
2492 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2493 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2495 alpha_elf_tdata(abfd)->total_got_entries++;
2496 alpha_elf_tdata(abfd)->n_local_got_entries++;
2499 gotent->use_count += 1;
2502 /* Remember how this literal is used from its LITUSEs.
2503 This will be important when it comes to decide if we can
2504 create a .plt entry for a function symbol. */
2506 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2511 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2512 flags |= 1 << rel->r_addend;
2514 while (rel+1 < relend &&
2515 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2519 /* No LITUSEs -- presumably the address is not being
2520 loaded for nothing. */
2521 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2524 gotent->flags |= flags;
2527 /* Make a guess as to whether a .plt entry will be needed. */
2528 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2529 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2531 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2536 case R_ALPHA_GPDISP:
2537 case R_ALPHA_GPREL32:
2538 case R_ALPHA_GPRELHIGH:
2539 case R_ALPHA_GPRELLOW:
2540 /* We don't actually use the .got here, but the sections must
2541 be created before the linker maps input sections to output
2545 if (!elf64_alpha_create_got_section (abfd, info))
2548 /* Make sure the object's gotobj is set to itself so
2549 that we default to every object with its own .got.
2550 We'll merge .gots later once we've collected each
2552 alpha_elf_tdata(abfd)->gotobj = abfd;
2558 case R_ALPHA_SREL16:
2559 case R_ALPHA_SREL32:
2560 case R_ALPHA_SREL64:
2565 case R_ALPHA_REFLONG:
2566 case R_ALPHA_REFQUAD:
2567 if (rel_sec_name == NULL)
2569 rel_sec_name = (bfd_elf_string_from_elf_section
2570 (abfd, elf_elfheader(abfd)->e_shstrndx,
2571 elf_section_data(sec)->rel_hdr.sh_name));
2572 if (rel_sec_name == NULL)
2575 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2576 && strcmp (bfd_get_section_name (abfd, sec),
2577 rel_sec_name+5) == 0);
2580 /* We need to create the section here now whether we eventually
2581 use it or not so that it gets mapped to an output section by
2582 the linker. If not used, we'll kill it in
2583 size_dynamic_sections. */
2586 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2589 sreloc = bfd_make_section (dynobj, rel_sec_name);
2591 || !bfd_set_section_flags (dynobj, sreloc,
2598 | SEC_LINKER_CREATED
2600 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2607 /* Since we havn't seen all of the input symbols yet, we
2608 don't know whether we'll actually need a dynamic relocation
2609 entry for this reloc. So make a record of it. Once we
2610 find out if this thing needs dynamic relocation we'll
2611 expand the relocation sections by the appropriate amount. */
2613 struct alpha_elf_reloc_entry *rent;
2615 for (rent = h->reloc_entries; rent; rent = rent->next)
2616 if (rent->rtype == r_type && rent->srel == sreloc)
2621 rent = ((struct alpha_elf_reloc_entry *)
2623 sizeof (struct alpha_elf_reloc_entry)));
2627 rent->srel = sreloc;
2628 rent->rtype = r_type;
2631 rent->next = h->reloc_entries;
2632 h->reloc_entries = rent;
2637 else if (info->shared && (sec->flags & SEC_ALLOC))
2639 /* If this is a shared library, and the section is to be
2640 loaded into memory, we need a RELATIVE reloc. */
2641 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2650 /* Adjust a symbol defined by a dynamic object and referenced by a
2651 regular object. The current definition is in some section of the
2652 dynamic object, but we're not including those sections. We have to
2653 change the definition to something the rest of the link can
2657 elf64_alpha_adjust_dynamic_symbol (info, h)
2658 struct bfd_link_info *info;
2659 struct elf_link_hash_entry *h;
2663 struct alpha_elf_link_hash_entry *ah;
2665 dynobj = elf_hash_table(info)->dynobj;
2666 ah = (struct alpha_elf_link_hash_entry *)h;
2668 /* Now that we've seen all of the input symbols, finalize our decision
2669 about whether this symbol should get a .plt entry. */
2671 if (h->root.type != bfd_link_hash_undefweak
2672 && alpha_elf_dynamic_symbol_p (h, info)
2673 && ((h->type == STT_FUNC
2674 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2675 || (h->type == STT_NOTYPE
2676 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2677 /* Don't prevent otherwise valid programs from linking by attempting
2678 to create a new .got entry somewhere. A Correct Solution would be
2679 to add a new .got section to a new object file and let it be merged
2680 somewhere later. But for now don't bother. */
2683 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2685 s = bfd_get_section_by_name(dynobj, ".plt");
2686 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2689 /* The first bit of the .plt is reserved. */
2690 if (s->_raw_size == 0)
2691 s->_raw_size = PLT_HEADER_SIZE;
2693 h->plt.offset = s->_raw_size;
2694 s->_raw_size += PLT_ENTRY_SIZE;
2696 /* If this symbol is not defined in a regular file, and we are not
2697 generating a shared library, then set the symbol to the location
2698 in the .plt. This is required to make function pointers compare
2699 equal between the normal executable and the shared library. */
2701 && h->root.type != bfd_link_hash_defweak)
2703 h->root.u.def.section = s;
2704 h->root.u.def.value = h->plt.offset;
2707 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2708 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2709 BFD_ASSERT (s != NULL);
2710 s->_raw_size += sizeof (Elf64_External_Rela);
2715 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2717 /* If this is a weak symbol, and there is a real definition, the
2718 processor independent code will have arranged for us to see the
2719 real definition first, and we can just use the same value. */
2720 if (h->weakdef != NULL)
2722 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2723 || h->weakdef->root.type == bfd_link_hash_defweak);
2724 h->root.u.def.section = h->weakdef->root.u.def.section;
2725 h->root.u.def.value = h->weakdef->root.u.def.value;
2729 /* This is a reference to a symbol defined by a dynamic object which
2730 is not a function. The Alpha, since it uses .got entries for all
2731 symbols even in regular objects, does not need the hackery of a
2732 .dynbss section and COPY dynamic relocations. */
2737 /* Symbol versioning can create new symbols, and make our old symbols
2738 indirect to the new ones. Consolidate the got and reloc information
2739 in these situations. */
2742 elf64_alpha_merge_ind_symbols (hi, dummy)
2743 struct alpha_elf_link_hash_entry *hi;
2744 PTR dummy ATTRIBUTE_UNUSED;
2746 struct alpha_elf_link_hash_entry *hs;
2748 if (hi->root.root.type != bfd_link_hash_indirect)
2752 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2753 } while (hs->root.root.type == bfd_link_hash_indirect);
2755 /* Merge the flags. Whee. */
2757 hs->flags |= hi->flags;
2759 /* Merge the .got entries. Cannibalize the old symbol's list in
2760 doing so, since we don't need it anymore. */
2762 if (hs->got_entries == NULL)
2763 hs->got_entries = hi->got_entries;
2766 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2768 gsh = hs->got_entries;
2769 for (gi = hi->got_entries; gi ; gi = gin)
2772 for (gs = gsh; gs ; gs = gs->next)
2773 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2775 gi->next = hs->got_entries;
2776 hs->got_entries = gi;
2780 hi->got_entries = NULL;
2782 /* And similar for the reloc entries. */
2784 if (hs->reloc_entries == NULL)
2785 hs->reloc_entries = hi->reloc_entries;
2788 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2790 rsh = hs->reloc_entries;
2791 for (ri = hi->reloc_entries; ri ; ri = rin)
2794 for (rs = rsh; rs ; rs = rs->next)
2795 if (ri->rtype == rs->rtype)
2797 rs->count += ri->count;
2800 ri->next = hs->reloc_entries;
2801 hs->reloc_entries = ri;
2805 hi->reloc_entries = NULL;
2810 /* Is it possible to merge two object file's .got tables? */
2813 elf64_alpha_can_merge_gots (a, b)
2816 int total = alpha_elf_tdata (a)->total_got_entries;
2819 /* Trivial quick fallout test. */
2820 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2823 /* By their nature, local .got entries cannot be merged. */
2824 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2827 /* Failing the common trivial comparison, we must effectively
2828 perform the merge. Not actually performing the merge means that
2829 we don't have to store undo information in case we fail. */
2830 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2832 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2833 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2836 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2837 for (i = 0; i < n; ++i)
2839 struct alpha_elf_got_entry *ae, *be;
2840 struct alpha_elf_link_hash_entry *h;
2843 while (h->root.root.type == bfd_link_hash_indirect
2844 || h->root.root.type == bfd_link_hash_warning)
2845 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2847 for (be = h->got_entries; be ; be = be->next)
2849 if (be->use_count == 0)
2851 if (be->gotobj != b)
2854 for (ae = h->got_entries; ae ; ae = ae->next)
2855 if (ae->gotobj == a && ae->addend == be->addend)
2858 if (++total > MAX_GOT_ENTRIES)
2868 /* Actually merge two .got tables. */
2871 elf64_alpha_merge_gots (a, b)
2874 int total = alpha_elf_tdata (a)->total_got_entries;
2877 /* Remember local expansion. */
2879 int e = alpha_elf_tdata (b)->n_local_got_entries;
2881 alpha_elf_tdata (a)->n_local_got_entries += e;
2884 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2886 struct alpha_elf_got_entry **local_got_entries;
2887 struct alpha_elf_link_hash_entry **hashes;
2888 Elf_Internal_Shdr *symtab_hdr;
2891 /* Let the local .got entries know they are part of a new subsegment. */
2892 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2893 if (local_got_entries)
2895 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2896 for (i = 0; i < n; ++i)
2898 struct alpha_elf_got_entry *ent;
2899 for (ent = local_got_entries[i]; ent; ent = ent->next)
2904 /* Merge the global .got entries. */
2905 hashes = alpha_elf_sym_hashes (bsub);
2906 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2908 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2909 for (i = 0; i < n; ++i)
2911 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2912 struct alpha_elf_link_hash_entry *h;
2915 while (h->root.root.type == bfd_link_hash_indirect
2916 || h->root.root.type == bfd_link_hash_warning)
2917 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2919 start = &h->got_entries;
2920 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2922 if (be->use_count == 0)
2927 if (be->gotobj != b)
2930 for (ae = *start; ae ; ae = ae->next)
2931 if (ae->gotobj == a && ae->addend == be->addend)
2933 ae->flags |= be->flags;
2934 ae->use_count += be->use_count;
2945 alpha_elf_tdata (bsub)->gotobj = a;
2947 alpha_elf_tdata (a)->total_got_entries = total;
2949 /* Merge the two in_got chains. */
2954 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2957 alpha_elf_tdata (bsub)->in_got_link_next = b;
2961 /* Calculate the offsets for the got entries. */
2964 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2965 struct alpha_elf_link_hash_entry *h;
2968 struct alpha_elf_got_entry *gotent;
2970 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2971 if (gotent->use_count > 0)
2974 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2976 gotent->got_offset = *plge;
2984 elf64_alpha_calc_got_offsets (info)
2985 struct bfd_link_info *info;
2987 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2989 /* First, zero out the .got sizes, as we may be recalculating the
2990 .got after optimizing it. */
2991 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2992 alpha_elf_tdata(i)->got->_raw_size = 0;
2994 /* Next, fill in the offsets for all the global entries. */
2995 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2996 elf64_alpha_calc_got_offsets_for_symbol,
2999 /* Finally, fill in the offsets for the local entries. */
3000 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3002 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
3005 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3007 struct alpha_elf_got_entry **local_got_entries, *gotent;
3010 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3011 if (!local_got_entries)
3014 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3015 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
3016 if (gotent->use_count > 0)
3018 gotent->got_offset = got_offset;
3023 alpha_elf_tdata(i)->got->_raw_size = got_offset;
3024 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
3028 /* Constructs the gots. */
3031 elf64_alpha_size_got_sections (output_bfd, info)
3033 struct bfd_link_info *info;
3035 bfd *i, *got_list, *cur_got_obj;
3036 int something_changed = 0;
3038 got_list = alpha_elf_hash_table (info)->got_list;
3040 /* On the first time through, pretend we have an existing got list
3041 consisting of all of the input files. */
3042 if (got_list == NULL)
3044 for (i = info->input_bfds; i ; i = i->link_next)
3046 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3047 if (this_got == NULL)
3050 /* We are assuming no merging has yet ocurred. */
3051 BFD_ASSERT (this_got == i);
3053 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
3055 /* Yikes! A single object file has too many entries. */
3056 (*_bfd_error_handler)
3057 (_("%s: .got subsegment exceeds 64K (size %d)"),
3058 bfd_get_filename (i),
3059 alpha_elf_tdata (this_got)->total_got_entries * 8);
3063 if (got_list == NULL)
3064 got_list = this_got;
3066 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3067 cur_got_obj = this_got;
3070 /* Strange degenerate case of no got references. */
3071 if (got_list == NULL)
3074 alpha_elf_hash_table (info)->got_list = got_list;
3076 /* Force got offsets to be recalculated. */
3077 something_changed = 1;
3080 cur_got_obj = got_list;
3081 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3084 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3086 elf64_alpha_merge_gots (cur_got_obj, i);
3087 i = alpha_elf_tdata(i)->got_link_next;
3088 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3089 something_changed = 1;
3094 i = alpha_elf_tdata(i)->got_link_next;
3098 /* Once the gots have been merged, fill in the got offsets for
3099 everything therein. */
3100 if (1 || something_changed)
3101 elf64_alpha_calc_got_offsets (info);
3107 elf64_alpha_always_size_sections (output_bfd, info)
3109 struct bfd_link_info *info;
3113 if (info->relocateable)
3116 /* First, take care of the indirect symbols created by versioning. */
3117 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3118 elf64_alpha_merge_ind_symbols,
3121 if (!elf64_alpha_size_got_sections (output_bfd, info))
3124 /* Allocate space for all of the .got subsections. */
3125 i = alpha_elf_hash_table (info)->got_list;
3126 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3128 asection *s = alpha_elf_tdata(i)->got;
3129 if (s->_raw_size > 0)
3131 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3132 if (s->contents == NULL)
3140 /* Work out the sizes of the dynamic relocation entries. */
3143 elf64_alpha_calc_dynrel_sizes (h, info)
3144 struct alpha_elf_link_hash_entry *h;
3145 struct bfd_link_info *info;
3147 /* If the symbol was defined as a common symbol in a regular object
3148 file, and there was no definition in any dynamic object, then the
3149 linker will have allocated space for the symbol in a common
3150 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3151 set. This is done for dynamic symbols in
3152 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3153 symbols, somehow. */
3154 if (((h->root.elf_link_hash_flags
3155 & (ELF_LINK_HASH_DEF_REGULAR
3156 | ELF_LINK_HASH_REF_REGULAR
3157 | ELF_LINK_HASH_DEF_DYNAMIC))
3158 == ELF_LINK_HASH_REF_REGULAR)
3159 && (h->root.root.type == bfd_link_hash_defined
3160 || h->root.root.type == bfd_link_hash_defweak)
3161 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3163 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3166 /* If the symbol is dynamic, we'll need all the relocations in their
3167 natural form. If this is a shared object, and it has been forced
3168 local, we'll need the same number of RELATIVE relocations. */
3170 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3172 struct alpha_elf_reloc_entry *relent;
3174 struct alpha_elf_got_entry *gotent;
3175 bfd_size_type count;
3178 for (relent = h->reloc_entries; relent; relent = relent->next)
3179 if (relent->rtype == R_ALPHA_REFLONG
3180 || relent->rtype == R_ALPHA_REFQUAD)
3182 relent->srel->_raw_size +=
3183 sizeof (Elf64_External_Rela) * relent->count;
3186 dynobj = elf_hash_table(info)->dynobj;
3189 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3192 /* If we are using a .plt entry, subtract one, as the first
3193 reference uses a .rela.plt entry instead. */
3194 if (h->root.plt.offset != MINUS_ONE)
3199 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3200 BFD_ASSERT (srel != NULL);
3201 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3208 /* Set the sizes of the dynamic sections. */
3211 elf64_alpha_size_dynamic_sections (output_bfd, info)
3213 struct bfd_link_info *info;
3220 dynobj = elf_hash_table(info)->dynobj;
3221 BFD_ASSERT(dynobj != NULL);
3223 if (elf_hash_table (info)->dynamic_sections_created)
3225 /* Set the contents of the .interp section to the interpreter. */
3228 s = bfd_get_section_by_name (dynobj, ".interp");
3229 BFD_ASSERT (s != NULL);
3230 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3231 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3234 /* Now that we've seen all of the input files, we can decide which
3235 symbols need dynamic relocation entries and which don't. We've
3236 collected information in check_relocs that we can now apply to
3237 size the dynamic relocation sections. */
3238 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3239 elf64_alpha_calc_dynrel_sizes,
3242 /* When building shared libraries, each local .got entry needs a
3248 bfd_size_type count;
3250 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3251 BFD_ASSERT (srel != NULL);
3253 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3255 i = alpha_elf_tdata(i)->got_link_next)
3256 count += alpha_elf_tdata(i)->n_local_got_entries;
3258 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3261 /* else we're not dynamic and by definition we don't need such things. */
3263 /* The check_relocs and adjust_dynamic_symbol entry points have
3264 determined the sizes of the various dynamic sections. Allocate
3268 for (s = dynobj->sections; s != NULL; s = s->next)
3273 if (!(s->flags & SEC_LINKER_CREATED))
3276 /* It's OK to base decisions on the section name, because none
3277 of the dynobj section names depend upon the input files. */
3278 name = bfd_get_section_name (dynobj, s);
3280 /* If we don't need this section, strip it from the output file.
3281 This is to handle .rela.bss and .rela.plt. We must create it
3282 in create_dynamic_sections, because it must be created before
3283 the linker maps input sections to output sections. The
3284 linker does that before adjust_dynamic_symbol is called, and
3285 it is that function which decides whether anything needs to
3286 go into these sections. */
3290 if (strncmp (name, ".rela", 5) == 0)
3292 strip = (s->_raw_size == 0);
3296 const char *outname;
3299 /* If this relocation section applies to a read only
3300 section, then we probably need a DT_TEXTREL entry. */
3301 outname = bfd_get_section_name (output_bfd,
3303 target = bfd_get_section_by_name (output_bfd, outname + 5);
3305 && (target->flags & SEC_READONLY) != 0
3306 && (target->flags & SEC_ALLOC) != 0)
3309 if (strcmp(name, ".rela.plt") == 0)
3312 /* We use the reloc_count field as a counter if we need
3313 to copy relocs into the output file. */
3317 else if (strcmp (name, ".plt") != 0)
3319 /* It's not one of our dynamic sections, so don't allocate space. */
3324 _bfd_strip_section_from_output (info, s);
3327 /* Allocate memory for the section contents. */
3328 s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3329 if (s->contents == NULL && s->_raw_size != 0)
3334 if (elf_hash_table (info)->dynamic_sections_created)
3336 /* Add some entries to the .dynamic section. We fill in the
3337 values later, in elf64_alpha_finish_dynamic_sections, but we
3338 must add the entries now so that we get the correct size for
3339 the .dynamic section. The DT_DEBUG entry is filled in by the
3340 dynamic linker and used by the debugger. */
3343 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3347 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3352 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3353 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3354 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3358 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3359 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3360 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3361 sizeof (Elf64_External_Rela)))
3366 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3368 info->flags |= DF_TEXTREL;
3375 /* Relocate an Alpha ELF section. */
3378 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3379 contents, relocs, local_syms, local_sections)
3381 struct bfd_link_info *info;
3383 asection *input_section;
3385 Elf_Internal_Rela *relocs;
3386 Elf_Internal_Sym *local_syms;
3387 asection **local_sections;
3389 Elf_Internal_Shdr *symtab_hdr;
3390 Elf_Internal_Rela *rel;
3391 Elf_Internal_Rela *relend;
3392 asection *sec, *sgot, *srel, *srelgot;
3393 bfd *dynobj, *gotobj;
3396 srelgot = srel = NULL;
3397 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3398 dynobj = elf_hash_table (info)->dynobj;
3401 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3404 /* Find the gp value for this input bfd. */
3407 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3410 sgot = alpha_elf_tdata (gotobj)->got;
3411 gp = _bfd_get_gp_value (gotobj);
3414 gp = (sgot->output_section->vma
3415 + sgot->output_offset
3417 _bfd_set_gp_value (gotobj, gp);
3422 relend = relocs + input_section->reloc_count;
3423 for (; rel < relend; rel++)
3426 reloc_howto_type *howto;
3427 unsigned long r_symndx;
3428 struct alpha_elf_link_hash_entry *h;
3429 Elf_Internal_Sym *sym;
3432 bfd_reloc_status_type r;
3434 r_type = ELF64_R_TYPE(rel->r_info);
3435 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3437 bfd_set_error (bfd_error_bad_value);
3440 howto = elf64_alpha_howto_table + r_type;
3442 r_symndx = ELF64_R_SYM(rel->r_info);
3444 if (info->relocateable)
3446 /* This is a relocateable link. We don't have to change
3447 anything, unless the reloc is against a section symbol,
3448 in which case we have to adjust according to where the
3449 section symbol winds up in the output section. */
3451 /* The symbol associated with GPDISP and LITUSE is
3452 immaterial. Only the addend is significant. */
3453 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3456 if (r_symndx < symtab_hdr->sh_info)
3458 sym = local_syms + r_symndx;
3459 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3461 sec = local_sections[r_symndx];
3462 rel->r_addend += sec->output_offset + sym->st_value;
3469 /* This is a final link. */
3475 if (r_symndx < symtab_hdr->sh_info)
3477 sym = local_syms + r_symndx;
3478 sec = local_sections[r_symndx];
3479 relocation = (sec->output_section->vma
3480 + sec->output_offset
3485 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3487 while (h->root.root.type == bfd_link_hash_indirect
3488 || h->root.root.type == bfd_link_hash_warning)
3489 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3491 if (h->root.root.type == bfd_link_hash_defined
3492 || h->root.root.type == bfd_link_hash_defweak)
3494 sec = h->root.root.u.def.section;
3497 if ((r_type == R_ALPHA_LITERAL
3498 && elf_hash_table(info)->dynamic_sections_created
3501 || !(h->root.elf_link_hash_flags
3502 & ELF_LINK_HASH_DEF_REGULAR)))
3505 || !(h->root.elf_link_hash_flags
3506 & ELF_LINK_HASH_DEF_REGULAR))
3507 && (input_section->flags & SEC_ALLOC)
3508 && (r_type == R_ALPHA_REFLONG
3509 || r_type == R_ALPHA_REFQUAD
3510 || r_type == R_ALPHA_LITERAL)))
3512 /* In these cases, we don't need the relocation value.
3513 We check specially because in some obscure cases
3514 sec->output_section will be NULL. */
3518 /* FIXME: Are not these obscure cases simply bugs? Let's
3519 get something working and come back to this. */
3520 if (sec->output_section == NULL)
3522 #endif /* rth_notdef */
3525 relocation = (h->root.root.u.def.value
3526 + sec->output_section->vma
3527 + sec->output_offset);
3530 else if (h->root.root.type == bfd_link_hash_undefweak)
3532 else if (info->shared && !info->symbolic
3533 && !info->no_undefined
3534 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3538 if (!((*info->callbacks->undefined_symbol)
3539 (info, h->root.root.root.string, input_bfd,
3540 input_section, rel->r_offset,
3541 (!info->shared || info->no_undefined
3542 || ELF_ST_VISIBILITY (h->root.other)))))
3547 addend = rel->r_addend;
3551 case R_ALPHA_GPDISP:
3553 bfd_byte *p_ldah, *p_lda;
3555 BFD_ASSERT(gp != 0);
3557 relocation = (input_section->output_section->vma
3558 + input_section->output_offset
3561 p_ldah = contents + rel->r_offset - input_section->vma;
3562 p_lda = p_ldah + rel->r_addend;
3564 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3569 case R_ALPHA_OP_PUSH:
3570 case R_ALPHA_OP_STORE:
3571 case R_ALPHA_OP_PSUB:
3572 case R_ALPHA_OP_PRSHIFT:
3573 /* We hate these silly beasts. */
3576 case R_ALPHA_LITERAL:
3578 struct alpha_elf_got_entry *gotent;
3579 boolean dynamic_symbol;
3581 BFD_ASSERT(sgot != NULL);
3582 BFD_ASSERT(gp != 0);
3586 gotent = h->got_entries;
3587 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3591 gotent = (alpha_elf_tdata(input_bfd)->
3592 local_got_entries[r_symndx]);
3593 dynamic_symbol = false;
3596 BFD_ASSERT(gotent != NULL);
3598 while (gotent->gotobj != gotobj || gotent->addend != addend)
3599 gotent = gotent->next;
3601 BFD_ASSERT(gotent->use_count >= 1);
3603 /* Initialize the .got entry's value. */
3604 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3606 bfd_put_64 (output_bfd, relocation+addend,
3607 sgot->contents + gotent->got_offset);
3609 /* If the symbol has been forced local, output a
3610 RELATIVE reloc, otherwise it will be handled in
3611 finish_dynamic_symbol. */
3612 if (info->shared && !dynamic_symbol)
3614 Elf_Internal_Rela outrel;
3616 BFD_ASSERT(srelgot != NULL);
3618 outrel.r_offset = (sgot->output_section->vma
3619 + sgot->output_offset
3620 + gotent->got_offset);
3621 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3622 outrel.r_addend = 0;
3624 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3625 ((Elf64_External_Rela *)
3627 + srelgot->reloc_count++);
3628 BFD_ASSERT (sizeof (Elf64_External_Rela)
3629 * srelgot->reloc_count
3630 <= srelgot->_cooked_size);
3633 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3636 /* Figure the gprel relocation. */
3638 relocation = (sgot->output_section->vma
3639 + sgot->output_offset
3640 + gotent->got_offset);
3643 /* overflow handled by _bfd_final_link_relocate */
3646 case R_ALPHA_GPREL32:
3647 case R_ALPHA_GPRELLOW:
3648 BFD_ASSERT(gp != 0);
3652 case R_ALPHA_GPRELHIGH:
3653 BFD_ASSERT(gp != 0);
3655 relocation += addend;
3657 relocation = (((bfd_signed_vma) relocation >> 16)
3658 + ((relocation >> 15) & 1));
3661 case R_ALPHA_BRADDR:
3663 /* The regular PC-relative stuff measures from the start of
3664 the instruction rather than the end. */
3668 case R_ALPHA_REFLONG:
3669 case R_ALPHA_REFQUAD:
3671 Elf_Internal_Rela outrel;
3674 /* Careful here to remember RELATIVE relocations for global
3675 variables for symbolic shared objects. */
3677 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3679 BFD_ASSERT(h->root.dynindx != -1);
3680 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3681 outrel.r_addend = addend;
3682 addend = 0, relocation = 0;
3684 else if (info->shared && (input_section->flags & SEC_ALLOC))
3686 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3687 outrel.r_addend = 0;
3696 name = (bfd_elf_string_from_elf_section
3697 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3698 elf_section_data(input_section)->rel_hdr.sh_name));
3699 BFD_ASSERT(name != NULL);
3701 srel = bfd_get_section_by_name (dynobj, name);
3702 BFD_ASSERT(srel != NULL);
3707 if (elf_section_data (input_section)->stab_info == NULL)
3708 outrel.r_offset = rel->r_offset;
3713 off = (_bfd_stab_section_offset
3714 (output_bfd, &elf_hash_table (info)->stab_info,
3716 &elf_section_data (input_section)->stab_info,
3718 if (off == (bfd_vma) -1)
3720 outrel.r_offset = off;
3724 outrel.r_offset += (input_section->output_section->vma
3725 + input_section->output_offset);
3727 memset (&outrel, 0, sizeof outrel);
3729 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3730 ((Elf64_External_Rela *)
3732 + srel->reloc_count++);
3733 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3734 <= srel->_cooked_size);
3740 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3741 contents, rel->r_offset, relocation,
3751 case bfd_reloc_overflow:
3756 name = h->root.root.root.string;
3759 name = (bfd_elf_string_from_elf_section
3760 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3764 name = bfd_section_name (input_bfd, sec);
3766 if (! ((*info->callbacks->reloc_overflow)
3767 (info, name, howto->name, (bfd_vma) 0,
3768 input_bfd, input_section, rel->r_offset)))
3774 case bfd_reloc_outofrange:
3782 /* Finish up dynamic symbol handling. We set the contents of various
3783 dynamic sections here. */
3786 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3788 struct bfd_link_info *info;
3789 struct elf_link_hash_entry *h;
3790 Elf_Internal_Sym *sym;
3792 bfd *dynobj = elf_hash_table(info)->dynobj;
3794 if (h->plt.offset != MINUS_ONE)
3796 /* Fill in the .plt entry for this symbol. */
3797 asection *splt, *sgot, *srel;
3798 Elf_Internal_Rela outrel;
3799 bfd_vma got_addr, plt_addr;
3801 struct alpha_elf_got_entry *gotent;
3803 BFD_ASSERT (h->dynindx != -1);
3805 /* The first .got entry will be updated by the .plt with the
3806 address of the target function. */
3807 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3808 BFD_ASSERT (gotent && gotent->addend == 0);
3810 splt = bfd_get_section_by_name (dynobj, ".plt");
3811 BFD_ASSERT (splt != NULL);
3812 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3813 BFD_ASSERT (srel != NULL);
3814 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3815 BFD_ASSERT (sgot != NULL);
3817 got_addr = (sgot->output_section->vma
3818 + sgot->output_offset
3819 + gotent->got_offset);
3820 plt_addr = (splt->output_section->vma
3821 + splt->output_offset
3824 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3826 /* Fill in the entry in the procedure linkage table. */
3828 unsigned insn1, insn2, insn3;
3830 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3831 insn2 = PLT_ENTRY_WORD2;
3832 insn3 = PLT_ENTRY_WORD3;
3834 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3835 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3836 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3839 /* Fill in the entry in the .rela.plt section. */
3840 outrel.r_offset = got_addr;
3841 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3842 outrel.r_addend = 0;
3844 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3845 ((Elf64_External_Rela *)srel->contents
3848 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3850 /* Mark the symbol as undefined, rather than as defined in the
3851 .plt section. Leave the value alone. */
3852 sym->st_shndx = SHN_UNDEF;
3855 /* Fill in the entries in the .got. */
3856 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3858 /* Subsequent .got entries will continue to bounce through the .plt. */
3861 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3862 BFD_ASSERT (! info->shared || srel != NULL);
3864 gotent = gotent->next;
3867 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3868 BFD_ASSERT(sgot != NULL);
3869 BFD_ASSERT(gotent->addend == 0);
3871 bfd_put_64 (output_bfd, plt_addr,
3872 sgot->contents + gotent->got_offset);
3876 outrel.r_offset = (sgot->output_section->vma
3877 + sgot->output_offset
3878 + gotent->got_offset);
3879 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3880 outrel.r_addend = 0;
3882 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3883 ((Elf64_External_Rela *)
3885 + srel->reloc_count++);
3886 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3887 <= srel->_cooked_size);
3890 gotent = gotent->next;
3892 while (gotent != NULL);
3895 else if (alpha_elf_dynamic_symbol_p (h, info))
3897 /* Fill in the dynamic relocations for this symbol's .got entries. */
3899 Elf_Internal_Rela outrel;
3900 struct alpha_elf_got_entry *gotent;
3902 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3903 BFD_ASSERT (srel != NULL);
3905 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3906 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3908 gotent = gotent->next)
3910 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3911 outrel.r_offset = (sgot->output_section->vma
3912 + sgot->output_offset
3913 + gotent->got_offset);
3914 outrel.r_addend = gotent->addend;
3916 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3917 ((Elf64_External_Rela *)srel->contents
3918 + srel->reloc_count++));
3919 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3920 <= srel->_cooked_size);
3924 /* Mark some specially defined symbols as absolute. */
3925 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3926 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3927 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3928 sym->st_shndx = SHN_ABS;
3933 /* Finish up the dynamic sections. */
3936 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3938 struct bfd_link_info *info;
3943 dynobj = elf_hash_table (info)->dynobj;
3944 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3946 if (elf_hash_table (info)->dynamic_sections_created)
3949 Elf64_External_Dyn *dyncon, *dynconend;
3951 splt = bfd_get_section_by_name (dynobj, ".plt");
3952 BFD_ASSERT (splt != NULL && sdyn != NULL);
3954 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3955 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3956 for (; dyncon < dynconend; dyncon++)
3958 Elf_Internal_Dyn dyn;
3962 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3977 /* My interpretation of the TIS v1.1 ELF document indicates
3978 that RELASZ should not include JMPREL. This is not what
3979 the rest of the BFD does. It is, however, what the
3980 glibc ld.so wants. Do this fixup here until we found
3981 out who is right. */
3982 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3986 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3991 s = bfd_get_section_by_name (output_bfd, name);
3992 dyn.d_un.d_ptr = (s ? s->vma : 0);
3996 s = bfd_get_section_by_name (output_bfd, name);
3998 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
4002 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
4005 /* Initialize the PLT0 entry */
4006 if (splt->_raw_size > 0)
4008 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
4009 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
4010 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
4011 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
4013 /* The next two words will be filled in by ld.so */
4014 bfd_put_64 (output_bfd, 0, splt->contents + 16);
4015 bfd_put_64 (output_bfd, 0, splt->contents + 24);
4017 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
4025 /* We need to use a special link routine to handle the .reginfo and
4026 the .mdebug sections. We need to merge all instances of these
4027 sections together, not write them all out sequentially. */
4030 elf64_alpha_final_link (abfd, info)
4032 struct bfd_link_info *info;
4035 struct bfd_link_order *p;
4036 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
4037 struct ecoff_debug_info debug;
4038 const struct ecoff_debug_swap *swap
4039 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4040 HDRR *symhdr = &debug.symbolic_header;
4041 PTR mdebug_handle = NULL;
4046 (*info->callbacks->warning)
4047 (info, _("using multiple gp values"), (char *) NULL,
4048 output_bfd, (asection *) NULL, (bfd_vma) 0);
4052 /* Go through the sections and collect the .reginfo and .mdebug
4056 gptab_data_sec = NULL;
4057 gptab_bss_sec = NULL;
4058 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4060 #ifdef ERIC_neverdef
4061 if (strcmp (o->name, ".reginfo") == 0)
4063 memset (®info, 0, sizeof reginfo);
4065 /* We have found the .reginfo section in the output file.
4066 Look through all the link_orders comprising it and merge
4067 the information together. */
4068 for (p = o->link_order_head;
4069 p != (struct bfd_link_order *) NULL;
4072 asection *input_section;
4074 Elf64_External_RegInfo ext;
4077 if (p->type != bfd_indirect_link_order)
4079 if (p->type == bfd_fill_link_order)
4084 input_section = p->u.indirect.section;
4085 input_bfd = input_section->owner;
4087 /* The linker emulation code has probably clobbered the
4088 size to be zero bytes. */
4089 if (input_section->_raw_size == 0)
4090 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4092 if (! bfd_get_section_contents (input_bfd, input_section,
4098 bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4100 reginfo.ri_gprmask |= sub.ri_gprmask;
4101 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4102 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4103 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4104 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4106 /* ri_gp_value is set by the function
4107 alpha_elf_section_processing when the section is
4108 finally written out. */
4110 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4111 elf_link_input_bfd ignores this section. */
4112 input_section->flags &=~ SEC_HAS_CONTENTS;
4115 /* Force the section size to the value we want. */
4116 o->_raw_size = sizeof (Elf64_External_RegInfo);
4118 /* Skip this section later on (I don't think this currently
4119 matters, but someday it might). */
4120 o->link_order_head = (struct bfd_link_order *) NULL;
4126 if (strcmp (o->name, ".mdebug") == 0)
4128 struct extsym_info einfo;
4130 /* We have found the .mdebug section in the output file.
4131 Look through all the link_orders comprising it and merge
4132 the information together. */
4133 symhdr->magic = swap->sym_magic;
4134 /* FIXME: What should the version stamp be? */
4136 symhdr->ilineMax = 0;
4140 symhdr->isymMax = 0;
4141 symhdr->ioptMax = 0;
4142 symhdr->iauxMax = 0;
4144 symhdr->issExtMax = 0;
4147 symhdr->iextMax = 0;
4149 /* We accumulate the debugging information itself in the
4150 debug_info structure. */
4152 debug.external_dnr = NULL;
4153 debug.external_pdr = NULL;
4154 debug.external_sym = NULL;
4155 debug.external_opt = NULL;
4156 debug.external_aux = NULL;
4158 debug.ssext = debug.ssext_end = NULL;
4159 debug.external_fdr = NULL;
4160 debug.external_rfd = NULL;
4161 debug.external_ext = debug.external_ext_end = NULL;
4163 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4164 if (mdebug_handle == (PTR) NULL)
4173 static const char * const name[] =
4175 ".text", ".init", ".fini", ".data",
4176 ".rodata", ".sdata", ".sbss", ".bss"
4178 static const int sc[] = { scText, scInit, scFini, scData,
4179 scRData, scSData, scSBss, scBss };
4182 esym.cobol_main = 0;
4186 esym.asym.iss = issNil;
4187 esym.asym.st = stLocal;
4188 esym.asym.reserved = 0;
4189 esym.asym.index = indexNil;
4190 for (i = 0; i < 8; i++)
4192 esym.asym.sc = sc[i];
4193 s = bfd_get_section_by_name (abfd, name[i]);
4196 esym.asym.value = s->vma;
4197 last = s->vma + s->_raw_size;
4200 esym.asym.value = last;
4202 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4208 for (p = o->link_order_head;
4209 p != (struct bfd_link_order *) NULL;
4212 asection *input_section;
4214 const struct ecoff_debug_swap *input_swap;
4215 struct ecoff_debug_info input_debug;
4219 if (p->type != bfd_indirect_link_order)
4221 if (p->type == bfd_fill_link_order)
4226 input_section = p->u.indirect.section;
4227 input_bfd = input_section->owner;
4229 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4230 || (get_elf_backend_data (input_bfd)
4231 ->elf_backend_ecoff_debug_swap) == NULL)
4233 /* I don't know what a non ALPHA ELF bfd would be
4234 doing with a .mdebug section, but I don't really
4235 want to deal with it. */
4239 input_swap = (get_elf_backend_data (input_bfd)
4240 ->elf_backend_ecoff_debug_swap);
4242 BFD_ASSERT (p->size == input_section->_raw_size);
4244 /* The ECOFF linking code expects that we have already
4245 read in the debugging information and set up an
4246 ecoff_debug_info structure, so we do that now. */
4247 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4251 if (! (bfd_ecoff_debug_accumulate
4252 (mdebug_handle, abfd, &debug, swap, input_bfd,
4253 &input_debug, input_swap, info)))
4256 /* Loop through the external symbols. For each one with
4257 interesting information, try to find the symbol in
4258 the linker global hash table and save the information
4259 for the output external symbols. */
4260 eraw_src = input_debug.external_ext;
4261 eraw_end = (eraw_src
4262 + (input_debug.symbolic_header.iextMax
4263 * input_swap->external_ext_size));
4265 eraw_src < eraw_end;
4266 eraw_src += input_swap->external_ext_size)
4270 struct alpha_elf_link_hash_entry *h;
4272 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4273 if (ext.asym.sc == scNil
4274 || ext.asym.sc == scUndefined
4275 || ext.asym.sc == scSUndefined)
4278 name = input_debug.ssext + ext.asym.iss;
4279 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4280 name, false, false, true);
4281 if (h == NULL || h->esym.ifd != -2)
4287 < input_debug.symbolic_header.ifdMax);
4288 ext.ifd = input_debug.ifdmap[ext.ifd];
4294 /* Free up the information we just read. */
4295 free (input_debug.line);
4296 free (input_debug.external_dnr);
4297 free (input_debug.external_pdr);
4298 free (input_debug.external_sym);
4299 free (input_debug.external_opt);
4300 free (input_debug.external_aux);
4301 free (input_debug.ss);
4302 free (input_debug.ssext);
4303 free (input_debug.external_fdr);
4304 free (input_debug.external_rfd);
4305 free (input_debug.external_ext);
4307 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4308 elf_link_input_bfd ignores this section. */
4309 input_section->flags &=~ SEC_HAS_CONTENTS;
4312 #ifdef ERIC_neverdef
4315 /* Create .rtproc section. */
4316 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4317 if (rtproc_sec == NULL)
4319 flagword flags = (SEC_HAS_CONTENTS
4321 | SEC_LINKER_CREATED
4324 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4325 if (rtproc_sec == NULL
4326 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4327 || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4331 if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4332 info, rtproc_sec, &debug))
4337 /* Build the external symbol information. */
4340 einfo.debug = &debug;
4342 einfo.failed = false;
4343 elf_link_hash_traverse (elf_hash_table (info),
4344 elf64_alpha_output_extsym,
4349 /* Set the size of the .mdebug section. */
4350 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4352 /* Skip this section later on (I don't think this currently
4353 matters, but someday it might). */
4354 o->link_order_head = (struct bfd_link_order *) NULL;
4359 #ifdef ERIC_neverdef
4360 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4362 const char *subname;
4365 Elf64_External_gptab *ext_tab;
4368 /* The .gptab.sdata and .gptab.sbss sections hold
4369 information describing how the small data area would
4370 change depending upon the -G switch. These sections
4371 not used in executables files. */
4372 if (! info->relocateable)
4376 for (p = o->link_order_head;
4377 p != (struct bfd_link_order *) NULL;
4380 asection *input_section;
4382 if (p->type != bfd_indirect_link_order)
4384 if (p->type == bfd_fill_link_order)
4389 input_section = p->u.indirect.section;
4391 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4392 elf_link_input_bfd ignores this section. */
4393 input_section->flags &=~ SEC_HAS_CONTENTS;
4396 /* Skip this section later on (I don't think this
4397 currently matters, but someday it might). */
4398 o->link_order_head = (struct bfd_link_order *) NULL;
4400 /* Really remove the section. */
4401 for (secpp = &abfd->sections;
4403 secpp = &(*secpp)->next)
4405 *secpp = (*secpp)->next;
4406 --abfd->section_count;
4411 /* There is one gptab for initialized data, and one for
4412 uninitialized data. */
4413 if (strcmp (o->name, ".gptab.sdata") == 0)
4415 else if (strcmp (o->name, ".gptab.sbss") == 0)
4419 (*_bfd_error_handler)
4420 (_("%s: illegal section name `%s'"),
4421 bfd_get_filename (abfd), o->name);
4422 bfd_set_error (bfd_error_nonrepresentable_section);
4426 /* The linker script always combines .gptab.data and
4427 .gptab.sdata into .gptab.sdata, and likewise for
4428 .gptab.bss and .gptab.sbss. It is possible that there is
4429 no .sdata or .sbss section in the output file, in which
4430 case we must change the name of the output section. */
4431 subname = o->name + sizeof ".gptab" - 1;
4432 if (bfd_get_section_by_name (abfd, subname) == NULL)
4434 if (o == gptab_data_sec)
4435 o->name = ".gptab.data";
4437 o->name = ".gptab.bss";
4438 subname = o->name + sizeof ".gptab" - 1;
4439 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4442 /* Set up the first entry. */
4444 tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4447 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4448 tab[0].gt_header.gt_unused = 0;
4450 /* Combine the input sections. */
4451 for (p = o->link_order_head;
4452 p != (struct bfd_link_order *) NULL;
4455 asection *input_section;
4459 bfd_size_type gpentry;
4461 if (p->type != bfd_indirect_link_order)
4463 if (p->type == bfd_fill_link_order)
4468 input_section = p->u.indirect.section;
4469 input_bfd = input_section->owner;
4471 /* Combine the gptab entries for this input section one
4472 by one. We know that the input gptab entries are
4473 sorted by ascending -G value. */
4474 size = bfd_section_size (input_bfd, input_section);
4476 for (gpentry = sizeof (Elf64_External_gptab);
4478 gpentry += sizeof (Elf64_External_gptab))
4480 Elf64_External_gptab ext_gptab;
4481 Elf64_gptab int_gptab;
4487 if (! (bfd_get_section_contents
4488 (input_bfd, input_section, (PTR) &ext_gptab,
4489 gpentry, sizeof (Elf64_External_gptab))))
4495 bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4497 val = int_gptab.gt_entry.gt_g_value;
4498 add = int_gptab.gt_entry.gt_bytes - last;
4501 for (look = 1; look < c; look++)
4503 if (tab[look].gt_entry.gt_g_value >= val)
4504 tab[look].gt_entry.gt_bytes += add;
4506 if (tab[look].gt_entry.gt_g_value == val)
4512 Elf64_gptab *new_tab;
4515 /* We need a new table entry. */
4516 new_tab = ((Elf64_gptab *)
4517 bfd_realloc ((PTR) tab,
4518 (c + 1) * sizeof (Elf64_gptab)));
4519 if (new_tab == NULL)
4525 tab[c].gt_entry.gt_g_value = val;
4526 tab[c].gt_entry.gt_bytes = add;
4528 /* Merge in the size for the next smallest -G
4529 value, since that will be implied by this new
4532 for (look = 1; look < c; look++)
4534 if (tab[look].gt_entry.gt_g_value < val
4536 || (tab[look].gt_entry.gt_g_value
4537 > tab[max].gt_entry.gt_g_value)))
4541 tab[c].gt_entry.gt_bytes +=
4542 tab[max].gt_entry.gt_bytes;
4547 last = int_gptab.gt_entry.gt_bytes;
4550 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4551 elf_link_input_bfd ignores this section. */
4552 input_section->flags &=~ SEC_HAS_CONTENTS;
4555 /* The table must be sorted by -G value. */
4557 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4559 /* Swap out the table. */
4560 ext_tab = ((Elf64_External_gptab *)
4561 bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4562 if (ext_tab == NULL)
4568 for (i = 0; i < c; i++)
4569 bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4572 o->_raw_size = c * sizeof (Elf64_External_gptab);
4573 o->contents = (bfd_byte *) ext_tab;
4575 /* Skip this section later on (I don't think this currently
4576 matters, but someday it might). */
4577 o->link_order_head = (struct bfd_link_order *) NULL;
4583 /* Invoke the regular ELF backend linker to do all the work. */
4584 if (! bfd_elf64_bfd_final_link (abfd, info))
4587 /* Now write out the computed sections. */
4589 /* The .got subsections... */
4591 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4592 for (i = alpha_elf_hash_table(info)->got_list;
4594 i = alpha_elf_tdata(i)->got_link_next)
4598 /* elf_bfd_final_link already did everything in dynobj. */
4602 sgot = alpha_elf_tdata(i)->got;
4603 if (! bfd_set_section_contents (abfd, sgot->output_section,
4604 sgot->contents, sgot->output_offset,
4610 #ifdef ERIC_neverdef
4611 if (reginfo_sec != (asection *) NULL)
4613 Elf64_External_RegInfo ext;
4615 bfd_alpha_elf64_swap_reginfo_out (abfd, ®info, &ext);
4616 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4617 (file_ptr) 0, sizeof ext))
4622 if (mdebug_sec != (asection *) NULL)
4624 BFD_ASSERT (abfd->output_has_begun);
4625 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4627 mdebug_sec->filepos))
4630 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4633 if (gptab_data_sec != (asection *) NULL)
4635 if (! bfd_set_section_contents (abfd, gptab_data_sec,
4636 gptab_data_sec->contents,
4638 gptab_data_sec->_raw_size))
4642 if (gptab_bss_sec != (asection *) NULL)
4644 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4645 gptab_bss_sec->contents,
4647 gptab_bss_sec->_raw_size))
4654 /* ECOFF swapping routines. These are used when dealing with the
4655 .mdebug section, which is in the ECOFF debugging format. Copied
4656 from elf32-mips.c. */
4657 static const struct ecoff_debug_swap
4658 elf64_alpha_ecoff_debug_swap =
4660 /* Symbol table magic number. */
4662 /* Alignment of debugging information. E.g., 4. */
4664 /* Sizes of external symbolic information. */
4665 sizeof (struct hdr_ext),
4666 sizeof (struct dnr_ext),
4667 sizeof (struct pdr_ext),
4668 sizeof (struct sym_ext),
4669 sizeof (struct opt_ext),
4670 sizeof (struct fdr_ext),
4671 sizeof (struct rfd_ext),
4672 sizeof (struct ext_ext),
4673 /* Functions to swap in external symbolic data. */
4682 _bfd_ecoff_swap_tir_in,
4683 _bfd_ecoff_swap_rndx_in,
4684 /* Functions to swap out external symbolic data. */
4693 _bfd_ecoff_swap_tir_out,
4694 _bfd_ecoff_swap_rndx_out,
4695 /* Function to read in symbolic data. */
4696 elf64_alpha_read_ecoff_info
4699 /* Use a non-standard hash bucket size of 8. */
4701 const struct elf_size_info alpha_elf_size_info =
4703 sizeof (Elf64_External_Ehdr),
4704 sizeof (Elf64_External_Phdr),
4705 sizeof (Elf64_External_Shdr),
4706 sizeof (Elf64_External_Rel),
4707 sizeof (Elf64_External_Rela),
4708 sizeof (Elf64_External_Sym),
4709 sizeof (Elf64_External_Dyn),
4710 sizeof (Elf_External_Note),
4714 ELFCLASS64, EV_CURRENT,
4715 bfd_elf64_write_out_phdrs,
4716 bfd_elf64_write_shdrs_and_ehdr,
4717 bfd_elf64_write_relocs,
4718 bfd_elf64_swap_symbol_out,
4719 bfd_elf64_slurp_reloc_table,
4720 bfd_elf64_slurp_symbol_table,
4721 bfd_elf64_swap_dyn_in,
4722 bfd_elf64_swap_dyn_out,
4729 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4730 #define TARGET_LITTLE_NAME "elf64-alpha"
4731 #define ELF_ARCH bfd_arch_alpha
4732 #define ELF_MACHINE_CODE EM_ALPHA
4733 #define ELF_MAXPAGESIZE 0x10000
4735 #define bfd_elf64_bfd_link_hash_table_create \
4736 elf64_alpha_bfd_link_hash_table_create
4738 #define bfd_elf64_bfd_reloc_type_lookup \
4739 elf64_alpha_bfd_reloc_type_lookup
4740 #define elf_info_to_howto \
4741 elf64_alpha_info_to_howto
4743 #define bfd_elf64_mkobject \
4744 elf64_alpha_mkobject
4745 #define elf_backend_object_p \
4746 elf64_alpha_object_p
4748 #define elf_backend_section_from_shdr \
4749 elf64_alpha_section_from_shdr
4750 #define elf_backend_fake_sections \
4751 elf64_alpha_fake_sections
4753 #define bfd_elf64_bfd_is_local_label_name \
4754 elf64_alpha_is_local_label_name
4755 #define bfd_elf64_find_nearest_line \
4756 elf64_alpha_find_nearest_line
4757 #define bfd_elf64_bfd_relax_section \
4758 elf64_alpha_relax_section
4760 #define elf_backend_add_symbol_hook \
4761 elf64_alpha_add_symbol_hook
4762 #define elf_backend_check_relocs \
4763 elf64_alpha_check_relocs
4764 #define elf_backend_create_dynamic_sections \
4765 elf64_alpha_create_dynamic_sections
4766 #define elf_backend_adjust_dynamic_symbol \
4767 elf64_alpha_adjust_dynamic_symbol
4768 #define elf_backend_always_size_sections \
4769 elf64_alpha_always_size_sections
4770 #define elf_backend_size_dynamic_sections \
4771 elf64_alpha_size_dynamic_sections
4772 #define elf_backend_relocate_section \
4773 elf64_alpha_relocate_section
4774 #define elf_backend_finish_dynamic_symbol \
4775 elf64_alpha_finish_dynamic_symbol
4776 #define elf_backend_finish_dynamic_sections \
4777 elf64_alpha_finish_dynamic_sections
4778 #define bfd_elf64_bfd_final_link \
4779 elf64_alpha_final_link
4781 #define elf_backend_ecoff_debug_swap \
4782 &elf64_alpha_ecoff_debug_swap
4784 #define elf_backend_size_info \
4787 /* A few constants that determine how the .plt section is set up. */
4788 #define elf_backend_want_got_plt 0
4789 #define elf_backend_plt_readonly 0
4790 #define elf_backend_want_plt_sym 1
4791 #define elf_backend_got_header_size 0
4792 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4794 #include "elf64-target.h"