1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry
*, struct bfd_link_info
*));
52 static struct bfd_hash_entry
* elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
54 static struct bfd_link_hash_table
* elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd
*, bfd_vma
, bfd_byte
*, bfd_byte
*));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
66 static reloc_howto_type
* elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd
*, bfd_reloc_code_real_type
));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd
*, arelent
*, Elf64_Internal_Rela
*));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd
*, Elf64_Internal_Shdr
*, char *));
77 static boolean elf64_alpha_fake_sections
78 PARAMS((bfd
*, Elf64_Internal_Shdr
*, asection
*));
79 static boolean elf64_alpha_create_got_section
80 PARAMS((bfd
*, struct bfd_link_info
*));
81 static boolean elf64_alpha_create_dynamic_sections
82 PARAMS((bfd
*, struct bfd_link_info
*));
84 static boolean elf64_alpha_read_ecoff_info
85 PARAMS((bfd
*, asection
*, struct ecoff_debug_info
*));
86 static boolean elf64_alpha_is_local_label_name
87 PARAMS((bfd
*, const char *));
88 static boolean elf64_alpha_find_nearest_line
89 PARAMS((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
90 const char **, unsigned int *));
92 #if defined(__STDC__) || defined(ALMOST_STDC)
93 struct alpha_elf_link_hash_entry
;
96 static boolean elf64_alpha_output_extsym
97 PARAMS((struct alpha_elf_link_hash_entry
*, PTR
));
99 static boolean elf64_alpha_can_merge_gots
100 PARAMS((bfd
*, bfd
*));
101 static void elf64_alpha_merge_gots
102 PARAMS((bfd
*, bfd
*));
103 static boolean elf64_alpha_calc_got_offsets_for_symbol
104 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
105 static void elf64_alpha_calc_got_offsets
PARAMS ((struct bfd_link_info
*));
106 static boolean elf64_alpha_size_got_sections
107 PARAMS ((bfd
*, struct bfd_link_info
*));
108 static boolean elf64_alpha_always_size_sections
109 PARAMS ((bfd
*, struct bfd_link_info
*));
110 static boolean elf64_alpha_calc_dynrel_sizes
111 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
112 static boolean elf64_alpha_add_symbol_hook
113 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
114 const char **, flagword
*, asection
**, bfd_vma
*));
115 static boolean elf64_alpha_check_relocs
116 PARAMS((bfd
*, struct bfd_link_info
*, asection
*sec
,
117 const Elf_Internal_Rela
*));
118 static boolean elf64_alpha_adjust_dynamic_symbol
119 PARAMS((struct bfd_link_info
*, struct elf_link_hash_entry
*));
120 static boolean elf64_alpha_size_dynamic_sections
121 PARAMS((bfd
*, struct bfd_link_info
*));
122 static boolean elf64_alpha_relocate_section
123 PARAMS((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
124 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
125 static boolean elf64_alpha_finish_dynamic_symbol
126 PARAMS((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
127 Elf_Internal_Sym
*));
128 static boolean elf64_alpha_finish_dynamic_sections
129 PARAMS((bfd
*, struct bfd_link_info
*));
130 static boolean elf64_alpha_final_link
131 PARAMS((bfd
*, struct bfd_link_info
*));
132 static boolean elf64_alpha_merge_ind_symbols
133 PARAMS((struct alpha_elf_link_hash_entry
*, PTR
));
134 static Elf_Internal_Rela
* elf64_alpha_find_reloc_at_ofs
135 PARAMS ((Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_vma
, int));
136 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
139 struct alpha_elf_link_hash_entry
141 struct elf_link_hash_entry root
;
143 /* External symbol information. */
146 /* Cumulative flags for all the .got entries. */
149 /* Contexts (LITUSE) in which a literal was referenced. */
150 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
151 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
152 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
153 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
155 /* Used to implement multiple .got subsections. */
156 struct alpha_elf_got_entry
158 struct alpha_elf_got_entry
*next
;
160 /* which .got subsection? */
163 /* the addend in effect for this entry. */
164 bfd_signed_vma addend
;
166 /* the .got offset for this entry. */
171 /* An additional flag. */
172 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
177 /* used to count non-got, non-plt relocations for delayed sizing
178 of relocation sections. */
179 struct alpha_elf_reloc_entry
181 struct alpha_elf_reloc_entry
*next
;
183 /* which .reloc section? */
186 /* what kind of relocation? */
189 /* is this against read-only section? */
190 unsigned int reltext
: 1;
192 /* how many did we find? */
197 /* Alpha ELF linker hash table. */
199 struct alpha_elf_link_hash_table
201 struct elf_link_hash_table root
;
203 /* The head of a list of .got subsections linked through
204 alpha_elf_tdata(abfd)->got_link_next. */
208 /* Look up an entry in a Alpha ELF linker hash table. */
210 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
211 ((struct alpha_elf_link_hash_entry *) \
212 elf_link_hash_lookup (&(table)->root, (string), (create), \
215 /* Traverse a Alpha ELF linker hash table. */
217 #define alpha_elf_link_hash_traverse(table, func, info) \
218 (elf_link_hash_traverse \
220 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
223 /* Get the Alpha ELF linker hash table from a link_info structure. */
225 #define alpha_elf_hash_table(p) \
226 ((struct alpha_elf_link_hash_table *) ((p)->hash))
228 /* Get the object's symbols as our own entry type. */
230 #define alpha_elf_sym_hashes(abfd) \
231 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
233 /* Should we do dynamic things to this symbol? */
236 alpha_elf_dynamic_symbol_p (h
, info
)
237 struct elf_link_hash_entry
*h
;
238 struct bfd_link_info
*info
;
243 while (h
->root
.type
== bfd_link_hash_indirect
244 || h
->root
.type
== bfd_link_hash_warning
)
245 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
247 if (h
->dynindx
== -1)
250 if (h
->root
.type
== bfd_link_hash_undefweak
251 || h
->root
.type
== bfd_link_hash_defweak
)
254 switch (ELF_ST_VISIBILITY (h
->other
))
262 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
267 if ((info
->shared
&& !info
->symbolic
)
268 || ((h
->elf_link_hash_flags
269 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
270 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
276 /* Create an entry in a Alpha ELF linker hash table. */
278 static struct bfd_hash_entry
*
279 elf64_alpha_link_hash_newfunc (entry
, table
, string
)
280 struct bfd_hash_entry
*entry
;
281 struct bfd_hash_table
*table
;
284 struct alpha_elf_link_hash_entry
*ret
=
285 (struct alpha_elf_link_hash_entry
*) entry
;
287 /* Allocate the structure if it has not already been allocated by a
289 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
290 ret
= ((struct alpha_elf_link_hash_entry
*)
291 bfd_hash_allocate (table
,
292 sizeof (struct alpha_elf_link_hash_entry
)));
293 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
294 return (struct bfd_hash_entry
*) ret
;
296 /* Call the allocation method of the superclass. */
297 ret
= ((struct alpha_elf_link_hash_entry
*)
298 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
300 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
302 /* Set local fields. */
303 memset (&ret
->esym
, 0, sizeof (EXTR
));
304 /* We use -2 as a marker to indicate that the information has
305 not been set. -1 means there is no associated ifd. */
308 ret
->got_entries
= NULL
;
309 ret
->reloc_entries
= NULL
;
312 return (struct bfd_hash_entry
*) ret
;
315 /* Create a Alpha ELF linker hash table. */
317 static struct bfd_link_hash_table
*
318 elf64_alpha_bfd_link_hash_table_create (abfd
)
321 struct alpha_elf_link_hash_table
*ret
;
323 ret
= ((struct alpha_elf_link_hash_table
*)
324 bfd_zalloc (abfd
, sizeof (struct alpha_elf_link_hash_table
)));
325 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
328 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
329 elf64_alpha_link_hash_newfunc
))
331 bfd_release (abfd
, ret
);
335 return &ret
->root
.root
;
338 /* We have some private fields hanging off of the elf_tdata structure. */
340 struct alpha_elf_obj_tdata
342 struct elf_obj_tdata root
;
344 /* For every input file, these are the got entries for that object's
346 struct alpha_elf_got_entry
** local_got_entries
;
348 /* For every input file, this is the object that owns the got that
349 this input file uses. */
352 /* For every got, this is a linked list through the objects using this got */
353 bfd
*in_got_link_next
;
355 /* For every got, this is a link to the next got subsegment. */
358 /* For every got, this is the section. */
361 /* For every got, this is it's total number of *entries*. */
362 int total_got_entries
;
364 /* For every got, this is the sum of the number of *entries* required
365 to hold all of the member object's local got. */
366 int n_local_got_entries
;
369 #define alpha_elf_tdata(abfd) \
370 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
373 elf64_alpha_mkobject (abfd
)
376 abfd
->tdata
.any
= bfd_zalloc (abfd
, sizeof (struct alpha_elf_obj_tdata
));
377 if (abfd
->tdata
.any
== NULL
)
383 elf64_alpha_object_p (abfd
)
386 /* Allocate our special target data. */
387 struct alpha_elf_obj_tdata
*new_tdata
;
388 new_tdata
= bfd_zalloc (abfd
, sizeof (struct alpha_elf_obj_tdata
));
389 if (new_tdata
== NULL
)
391 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
392 abfd
->tdata
.any
= new_tdata
;
394 /* Set the right machine number for an Alpha ELF file. */
395 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
398 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
399 from smaller values. Start with zero, widen, *then* decrement. */
400 #define MINUS_ONE (((bfd_vma)0) - 1)
402 #define SKIP_HOWTO(N) \
403 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
405 static reloc_howto_type elf64_alpha_howto_table
[] =
407 HOWTO (R_ALPHA_NONE
, /* type */
409 0, /* size (0 = byte, 1 = short, 2 = long) */
411 true, /* pc_relative */
413 complain_overflow_dont
, /* complain_on_overflow */
414 elf64_alpha_reloc_nil
, /* special_function */
416 false, /* partial_inplace */
419 true), /* pcrel_offset */
421 /* A 32 bit reference to a symbol. */
422 HOWTO (R_ALPHA_REFLONG
, /* type */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
426 false, /* pc_relative */
428 complain_overflow_bitfield
, /* complain_on_overflow */
429 0, /* special_function */
430 "REFLONG", /* name */
431 false, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 false), /* pcrel_offset */
436 /* A 64 bit reference to a symbol. */
437 HOWTO (R_ALPHA_REFQUAD
, /* type */
439 4, /* size (0 = byte, 1 = short, 2 = long) */
441 false, /* pc_relative */
443 complain_overflow_bitfield
, /* complain_on_overflow */
444 0, /* special_function */
445 "REFQUAD", /* name */
446 false, /* partial_inplace */
447 MINUS_ONE
, /* src_mask */
448 MINUS_ONE
, /* dst_mask */
449 false), /* pcrel_offset */
451 /* A 32 bit GP relative offset. This is just like REFLONG except
452 that when the value is used the value of the gp register will be
454 HOWTO (R_ALPHA_GPREL32
, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 false, /* pc_relative */
460 complain_overflow_bitfield
, /* complain_on_overflow */
461 0, /* special_function */
462 "GPREL32", /* name */
463 false, /* partial_inplace */
464 0xffffffff, /* src_mask */
465 0xffffffff, /* dst_mask */
466 false), /* pcrel_offset */
468 /* Used for an instruction that refers to memory off the GP register. */
469 HOWTO (R_ALPHA_LITERAL
, /* type */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
473 false, /* pc_relative */
475 complain_overflow_signed
, /* complain_on_overflow */
476 0, /* special_function */
477 "ELF_LITERAL", /* name */
478 false, /* partial_inplace */
479 0xffff, /* src_mask */
480 0xffff, /* dst_mask */
481 false), /* pcrel_offset */
483 /* This reloc only appears immediately following an ELF_LITERAL reloc.
484 It identifies a use of the literal. The symbol index is special:
485 1 means the literal address is in the base register of a memory
486 format instruction; 2 means the literal address is in the byte
487 offset register of a byte-manipulation instruction; 3 means the
488 literal address is in the target register of a jsr instruction.
489 This does not actually do any relocation. */
490 HOWTO (R_ALPHA_LITUSE
, /* type */
492 1, /* size (0 = byte, 1 = short, 2 = long) */
494 false, /* pc_relative */
496 complain_overflow_dont
, /* complain_on_overflow */
497 elf64_alpha_reloc_nil
, /* special_function */
499 false, /* partial_inplace */
502 false), /* pcrel_offset */
504 /* Load the gp register. This is always used for a ldah instruction
505 which loads the upper 16 bits of the gp register. The symbol
506 index of the GPDISP instruction is an offset in bytes to the lda
507 instruction that loads the lower 16 bits. The value to use for
508 the relocation is the difference between the GP value and the
509 current location; the load will always be done against a register
510 holding the current address.
512 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
513 any offset is present in the instructions, it is an offset from
514 the register to the ldah instruction. This lets us avoid any
515 stupid hackery like inventing a gp value to do partial relocation
516 against. Also unlike ECOFF, we do the whole relocation off of
517 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
518 space consuming bit, that, since all the information was present
519 in the GPDISP_HI16 reloc. */
520 HOWTO (R_ALPHA_GPDISP
, /* type */
522 2, /* size (0 = byte, 1 = short, 2 = long) */
524 false, /* pc_relative */
526 complain_overflow_dont
, /* complain_on_overflow */
527 elf64_alpha_reloc_gpdisp
, /* special_function */
529 false, /* partial_inplace */
530 0xffff, /* src_mask */
531 0xffff, /* dst_mask */
532 true), /* pcrel_offset */
534 /* A 21 bit branch. */
535 HOWTO (R_ALPHA_BRADDR
, /* type */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
539 true, /* pc_relative */
541 complain_overflow_signed
, /* complain_on_overflow */
542 0, /* special_function */
544 false, /* partial_inplace */
545 0x1fffff, /* src_mask */
546 0x1fffff, /* dst_mask */
547 true), /* pcrel_offset */
549 /* A hint for a jump to a register. */
550 HOWTO (R_ALPHA_HINT
, /* type */
552 1, /* size (0 = byte, 1 = short, 2 = long) */
554 true, /* pc_relative */
556 complain_overflow_dont
, /* complain_on_overflow */
557 0, /* special_function */
559 false, /* partial_inplace */
560 0x3fff, /* src_mask */
561 0x3fff, /* dst_mask */
562 true), /* pcrel_offset */
564 /* 16 bit PC relative offset. */
565 HOWTO (R_ALPHA_SREL16
, /* type */
567 1, /* size (0 = byte, 1 = short, 2 = long) */
569 true, /* pc_relative */
571 complain_overflow_signed
, /* complain_on_overflow */
572 0, /* special_function */
574 false, /* partial_inplace */
575 0xffff, /* src_mask */
576 0xffff, /* dst_mask */
577 true), /* pcrel_offset */
579 /* 32 bit PC relative offset. */
580 HOWTO (R_ALPHA_SREL32
, /* type */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
584 true, /* pc_relative */
586 complain_overflow_signed
, /* complain_on_overflow */
587 0, /* special_function */
589 false, /* partial_inplace */
590 0xffffffff, /* src_mask */
591 0xffffffff, /* dst_mask */
592 true), /* pcrel_offset */
594 /* A 64 bit PC relative offset. */
595 HOWTO (R_ALPHA_SREL64
, /* type */
597 4, /* size (0 = byte, 1 = short, 2 = long) */
599 true, /* pc_relative */
601 complain_overflow_signed
, /* complain_on_overflow */
602 0, /* special_function */
604 false, /* partial_inplace */
605 MINUS_ONE
, /* src_mask */
606 MINUS_ONE
, /* dst_mask */
607 true), /* pcrel_offset */
609 /* Skip 12 - 16; deprecated ECOFF relocs. */
616 /* The high 16 bits of the displacement from GP to the target. */
617 HOWTO (R_ALPHA_GPRELHIGH
,
619 1, /* size (0 = byte, 1 = short, 2 = long) */
621 false, /* pc_relative */
623 complain_overflow_signed
, /* complain_on_overflow */
624 0, /* special_function */
625 "GPRELHIGH", /* name */
626 false, /* partial_inplace */
627 0xffff, /* src_mask */
628 0xffff, /* dst_mask */
629 false), /* pcrel_offset */
631 /* The low 16 bits of the displacement from GP to the target. */
632 HOWTO (R_ALPHA_GPRELLOW
,
634 1, /* size (0 = byte, 1 = short, 2 = long) */
636 false, /* pc_relative */
638 complain_overflow_dont
, /* complain_on_overflow */
639 0, /* special_function */
640 "GPRELLOW", /* name */
641 false, /* partial_inplace */
642 0xffff, /* src_mask */
643 0xffff, /* dst_mask */
644 false), /* pcrel_offset */
646 /* A 16-bit displacement from the GP to the target. */
647 HOWTO (R_ALPHA_GPREL16
,
649 1, /* size (0 = byte, 1 = short, 2 = long) */
651 false, /* pc_relative */
653 complain_overflow_signed
, /* complain_on_overflow */
654 0, /* special_function */
655 "GPREL16", /* name */
656 false, /* partial_inplace */
657 0xffff, /* src_mask */
658 0xffff, /* dst_mask */
659 false), /* pcrel_offset */
661 /* Skip 20 - 23; deprecated ECOFF relocs. */
667 /* Misc ELF relocations. */
669 /* A dynamic relocation to copy the target into our .dynbss section. */
670 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
671 is present because every other ELF has one, but should not be used
672 because .dynbss is an ugly thing. */
679 complain_overflow_dont
,
680 bfd_elf_generic_reloc
,
687 /* A dynamic relocation for a .got entry. */
688 HOWTO (R_ALPHA_GLOB_DAT
,
694 complain_overflow_dont
,
695 bfd_elf_generic_reloc
,
702 /* A dynamic relocation for a .plt entry. */
703 HOWTO (R_ALPHA_JMP_SLOT
,
709 complain_overflow_dont
,
710 bfd_elf_generic_reloc
,
717 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
718 HOWTO (R_ALPHA_RELATIVE
,
724 complain_overflow_dont
,
725 bfd_elf_generic_reloc
,
733 /* A relocation function which doesn't do anything. */
735 static bfd_reloc_status_type
736 elf64_alpha_reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
737 bfd
*abfd ATTRIBUTE_UNUSED
;
739 asymbol
*sym ATTRIBUTE_UNUSED
;
740 PTR data ATTRIBUTE_UNUSED
;
743 char **error_message ATTRIBUTE_UNUSED
;
746 reloc
->address
+= sec
->output_offset
;
750 /* A relocation function used for an unsupported reloc. */
752 static bfd_reloc_status_type
753 elf64_alpha_reloc_bad (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
754 bfd
*abfd ATTRIBUTE_UNUSED
;
756 asymbol
*sym ATTRIBUTE_UNUSED
;
757 PTR data ATTRIBUTE_UNUSED
;
760 char **error_message ATTRIBUTE_UNUSED
;
763 reloc
->address
+= sec
->output_offset
;
764 return bfd_reloc_notsupported
;
767 /* Do the work of the GPDISP relocation. */
769 static bfd_reloc_status_type
770 elf64_alpha_do_reloc_gpdisp (abfd
, gpdisp
, p_ldah
, p_lda
)
776 bfd_reloc_status_type ret
= bfd_reloc_ok
;
778 unsigned long i_ldah
, i_lda
;
780 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
781 i_lda
= bfd_get_32 (abfd
, p_lda
);
783 /* Complain if the instructions are not correct. */
784 if (((i_ldah
>> 26) & 0x3f) != 0x09
785 || ((i_lda
>> 26) & 0x3f) != 0x08)
786 ret
= bfd_reloc_dangerous
;
788 /* Extract the user-supplied offset, mirroring the sign extensions
789 that the instructions perform. */
790 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
791 addend
= (addend
^ 0x80008000) - 0x80008000;
795 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
796 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
797 ret
= bfd_reloc_overflow
;
799 /* compensate for the sign extension again. */
800 i_ldah
= ((i_ldah
& 0xffff0000)
801 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
802 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
804 bfd_put_32 (abfd
, i_ldah
, p_ldah
);
805 bfd_put_32 (abfd
, i_lda
, p_lda
);
810 /* The special function for the GPDISP reloc. */
812 static bfd_reloc_status_type
813 elf64_alpha_reloc_gpdisp (abfd
, reloc_entry
, sym
, data
, input_section
,
816 arelent
*reloc_entry
;
817 asymbol
*sym ATTRIBUTE_UNUSED
;
819 asection
*input_section
;
823 bfd_reloc_status_type ret
;
824 bfd_vma gp
, relocation
;
825 bfd_byte
*p_ldah
, *p_lda
;
827 /* Don't do anything if we're not doing a final link. */
830 reloc_entry
->address
+= input_section
->output_offset
;
834 if (reloc_entry
->address
> input_section
->_cooked_size
||
835 reloc_entry
->address
+ reloc_entry
->addend
> input_section
->_cooked_size
)
836 return bfd_reloc_outofrange
;
838 /* The gp used in the portion of the output object to which this
839 input object belongs is cached on the input bfd. */
840 gp
= _bfd_get_gp_value (abfd
);
842 relocation
= (input_section
->output_section
->vma
843 + input_section
->output_offset
844 + reloc_entry
->address
);
846 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
847 p_lda
= p_ldah
+ reloc_entry
->addend
;
849 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
851 /* Complain if the instructions are not correct. */
852 if (ret
== bfd_reloc_dangerous
)
853 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
858 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
862 bfd_reloc_code_real_type bfd_reloc_val
;
866 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
868 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
869 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
870 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
871 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
872 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
873 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
874 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
875 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
876 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
877 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
878 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
879 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
880 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
881 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
882 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
883 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
886 /* Given a BFD reloc type, return a HOWTO structure. */
888 static reloc_howto_type
*
889 elf64_alpha_bfd_reloc_type_lookup (abfd
, code
)
890 bfd
*abfd ATTRIBUTE_UNUSED
;
891 bfd_reloc_code_real_type code
;
893 const struct elf_reloc_map
*i
, *e
;
894 i
= e
= elf64_alpha_reloc_map
;
895 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
898 if (i
->bfd_reloc_val
== code
)
899 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
904 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
907 elf64_alpha_info_to_howto (abfd
, cache_ptr
, dst
)
908 bfd
*abfd ATTRIBUTE_UNUSED
;
910 Elf64_Internal_Rela
*dst
;
914 r_type
= ELF64_R_TYPE(dst
->r_info
);
915 BFD_ASSERT (r_type
< (unsigned int) R_ALPHA_max
);
916 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
919 /* These functions do relaxation for Alpha ELF.
921 Currently I'm only handling what I can do with existing compiler
922 and assembler support, which means no instructions are removed,
923 though some may be nopped. At this time GCC does not emit enough
924 information to do all of the relaxing that is possible. It will
925 take some not small amount of work for that to happen.
927 There are a couple of interesting papers that I once read on this
928 subject, that I cannot find references to at the moment, that
929 related to Alpha in particular. They are by David Wall, then of
934 #define INSN_JSR 0x68004000
935 #define INSN_JSR_MASK 0xfc00c000
939 #define INSN_UNOP 0x2fe00000
941 struct alpha_relax_info
946 Elf_Internal_Rela
*relocs
, *relend
;
947 struct bfd_link_info
*link_info
;
948 boolean changed_contents
;
949 boolean changed_relocs
;
953 struct alpha_elf_link_hash_entry
*h
;
954 struct alpha_elf_got_entry
*gotent
;
958 static Elf_Internal_Rela
* elf64_alpha_relax_with_lituse
959 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
960 Elf_Internal_Rela
*irel
, Elf_Internal_Rela
*irelend
));
962 static boolean elf64_alpha_relax_without_lituse
963 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
964 Elf_Internal_Rela
*irel
));
966 static bfd_vma elf64_alpha_relax_opt_call
967 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
));
969 static boolean elf64_alpha_relax_section
970 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
973 static Elf_Internal_Rela
*
974 elf64_alpha_find_reloc_at_ofs (rel
, relend
, offset
, type
)
975 Elf_Internal_Rela
*rel
, *relend
;
981 if (rel
->r_offset
== offset
982 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
989 static Elf_Internal_Rela
*
990 elf64_alpha_relax_with_lituse (info
, symval
, irel
, irelend
)
991 struct alpha_relax_info
*info
;
993 Elf_Internal_Rela
*irel
, *irelend
;
995 Elf_Internal_Rela
*urel
;
1000 boolean lit_reused
= false;
1001 boolean all_optimized
= true;
1002 unsigned int lit_insn
;
1004 lit_insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1005 if (lit_insn
>> 26 != OP_LDQ
)
1007 ((*_bfd_error_handler
)
1008 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1009 bfd_get_filename (info
->abfd
), info
->sec
->name
,
1010 (unsigned long)irel
->r_offset
));
1014 /* Summarize how this particular LITERAL is used. */
1015 for (urel
= irel
+1, flags
= count
= 0; urel
< irelend
; ++urel
, ++count
)
1017 if (ELF64_R_TYPE (urel
->r_info
) != R_ALPHA_LITUSE
)
1019 if (urel
->r_addend
>= 0 && urel
->r_addend
<= 3)
1020 flags
|= 1 << urel
->r_addend
;
1023 /* A little preparation for the loop... */
1024 disp
= symval
- info
->gp
;
1026 for (urel
= irel
+1, i
= 0; i
< count
; ++i
, ++urel
)
1030 bfd_signed_vma xdisp
;
1032 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ urel
->r_offset
);
1034 switch (urel
->r_addend
)
1036 default: /* 0 = ADDRESS FORMAT */
1037 /* This type is really just a placeholder to note that all
1038 uses cannot be optimized, but to still allow some. */
1039 all_optimized
= false;
1042 case 1: /* MEM FORMAT */
1043 /* We can always optimize 16-bit displacements. */
1045 /* Extract the displacement from the instruction, sign-extending
1046 it if necessary, then test whether it is within 16 or 32 bits
1047 displacement from GP. */
1048 insn_disp
= insn
& 0x0000ffff;
1049 if (insn_disp
& 0x00008000)
1050 insn_disp
|= 0xffff0000; /* Negative: sign-extend. */
1052 xdisp
= disp
+ insn_disp
;
1053 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x00008000 && xdisp
< 0x00008000);
1054 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000 && xdisp
< 0x7fff8000);
1058 /* Take the op code and dest from this insn, take the base
1059 register from the literal insn. Leave the offset alone. */
1060 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
1061 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1063 urel
->r_addend
= irel
->r_addend
;
1064 info
->changed_relocs
= true;
1066 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ urel
->r_offset
);
1067 info
->changed_contents
= true;
1070 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1071 else if (fits32
&& !(flags
& ~6))
1073 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1075 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1077 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
1078 bfd_put_32 (info
->abfd
, lit_insn
,
1079 info
->contents
+ irel
->r_offset
);
1081 info
->changed_contents
= true;
1083 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1085 urel
->r_addend
= irel
->r_addend
;
1086 info
->changed_relocs
= true;
1089 all_optimized
= false;
1092 case 2: /* BYTE OFFSET FORMAT */
1093 /* We can always optimize byte instructions. */
1095 /* FIXME: sanity check the insn for byte op. Check that the
1096 literal dest reg is indeed Rb in the byte insn. */
1098 insn
= (insn
& ~0x001ff000) | ((symval
& 7) << 13) | 0x1000;
1100 urel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1102 info
->changed_relocs
= true;
1104 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ urel
->r_offset
);
1105 info
->changed_contents
= true;
1108 case 3: /* CALL FORMAT */
1110 /* If not zero, place to jump without needing pv. */
1111 bfd_vma optdest
= elf64_alpha_relax_opt_call (info
, symval
);
1112 bfd_vma org
= (info
->sec
->output_section
->vma
1113 + info
->sec
->output_offset
1114 + urel
->r_offset
+ 4);
1115 bfd_signed_vma odisp
;
1117 odisp
= (optdest
? optdest
: symval
) - org
;
1118 if (odisp
>= -0x400000 && odisp
< 0x400000)
1120 Elf_Internal_Rela
*xrel
;
1122 /* Preserve branch prediction call stack when possible. */
1123 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
1124 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
1126 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
1128 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1130 urel
->r_addend
= irel
->r_addend
;
1133 urel
->r_addend
+= optdest
- symval
;
1135 all_optimized
= false;
1137 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ urel
->r_offset
);
1139 /* Kill any HINT reloc that might exist for this insn. */
1140 xrel
= (elf64_alpha_find_reloc_at_ofs
1141 (info
->relocs
, info
->relend
, urel
->r_offset
,
1144 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1146 info
->changed_contents
= true;
1147 info
->changed_relocs
= true;
1150 all_optimized
= false;
1152 /* ??? If target gp == current gp we can eliminate the gp reload.
1153 This does depend on every place a gp could be reloaded will
1154 be, which currently happens for all code produced by gcc, but
1155 not necessarily by hand-coded assembly, or if sibling calls
1158 Perhaps conditionalize this on a flag being set in the target
1159 object file's header, and have gcc set it? */
1165 /* If all cases were optimized, we can reduce the use count on this
1166 got entry by one, possibly eliminating it. */
1169 info
->gotent
->use_count
-= 1;
1170 alpha_elf_tdata (info
->gotent
->gotobj
)->total_got_entries
-= 1;
1172 alpha_elf_tdata (info
->gotent
->gotobj
)->n_local_got_entries
-= 1;
1174 /* If the literal instruction is no longer needed (it may have been
1175 reused. We can eliminate it.
1176 ??? For now, I don't want to deal with compacting the section,
1177 so just nop it out. */
1180 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1181 info
->changed_relocs
= true;
1183 bfd_put_32 (info
->abfd
, INSN_UNOP
, info
->contents
+ irel
->r_offset
);
1184 info
->changed_contents
= true;
1188 return irel
+ count
;
1192 elf64_alpha_relax_opt_call (info
, symval
)
1193 struct alpha_relax_info
*info
;
1196 /* If the function has the same gp, and we can identify that the
1197 function does not use its function pointer, we can eliminate the
1200 /* If the symbol is marked NOPV, we are being told the function never
1201 needs its procedure value. */
1202 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
1205 /* If the symbol is marked STD_GP, we are being told the function does
1206 a normal ldgp in the first two words. */
1207 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
1210 /* Otherwise, we may be able to identify a GP load in the first two
1211 words, which we can then skip. */
1214 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
1217 /* Load the relocations from the section that the target symbol is in. */
1218 if (info
->sec
== info
->tsec
)
1220 tsec_relocs
= info
->relocs
;
1221 tsec_relend
= info
->relend
;
1226 tsec_relocs
= (_bfd_elf64_link_read_relocs
1227 (info
->abfd
, info
->tsec
, (PTR
) NULL
,
1228 (Elf_Internal_Rela
*) NULL
,
1229 info
->link_info
->keep_memory
));
1230 if (tsec_relocs
== NULL
)
1232 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
1233 tsec_free
= (info
->link_info
->keep_memory
? NULL
: tsec_relocs
);
1236 /* Recover the symbol's offset within the section. */
1237 ofs
= (symval
- info
->tsec
->output_section
->vma
1238 - info
->tsec
->output_offset
);
1240 /* Look for a GPDISP reloc. */
1241 gpdisp
= (elf64_alpha_find_reloc_at_ofs
1242 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
1244 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
1254 /* We've now determined that we can skip an initial gp load. Verify
1255 that the call and the target use the same gp. */
1256 if (info
->link_info
->hash
->creator
!= info
->tsec
->owner
->xvec
1257 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
1264 elf64_alpha_relax_without_lituse (info
, symval
, irel
)
1265 struct alpha_relax_info
*info
;
1267 Elf_Internal_Rela
*irel
;
1270 bfd_signed_vma disp
;
1272 /* Get the instruction. */
1273 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1275 if (insn
>> 26 != OP_LDQ
)
1277 ((*_bfd_error_handler
)
1278 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1279 bfd_get_filename (info
->abfd
), info
->sec
->name
,
1280 (unsigned long) irel
->r_offset
));
1284 /* So we aren't told much. Do what we can with the address load and
1285 fake the rest. All of the optimizations here require that the
1286 offset from the GP fit in 16 bits. */
1288 disp
= symval
- info
->gp
;
1289 if (disp
< -0x8000 || disp
>= 0x8000)
1292 /* On the LITERAL instruction itself, consider exchanging
1293 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1295 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
1296 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ irel
->r_offset
);
1297 info
->changed_contents
= true;
1299 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), R_ALPHA_GPREL16
);
1300 info
->changed_relocs
= true;
1302 /* Reduce the use count on this got entry by one, possibly
1304 info
->gotent
->use_count
-= 1;
1305 alpha_elf_tdata (info
->gotent
->gotobj
)->total_got_entries
-= 1;
1307 alpha_elf_tdata (info
->gotent
->gotobj
)->n_local_got_entries
-= 1;
1309 /* ??? Search forward through this basic block looking for insns
1310 that use the target register. Stop after an insn modifying the
1311 register is seen, or after a branch or call.
1313 Any such memory load insn may be substituted by a load directly
1314 off the GP. This allows the memory load insn to be issued before
1315 the calculated GP register would otherwise be ready.
1317 Any such jsr insn can be replaced by a bsr if it is in range.
1319 This would mean that we'd have to _add_ relocations, the pain of
1320 which gives one pause. */
1326 elf64_alpha_relax_section (abfd
, sec
, link_info
, again
)
1329 struct bfd_link_info
*link_info
;
1332 Elf_Internal_Shdr
*symtab_hdr
;
1333 Elf_Internal_Rela
*internal_relocs
;
1334 Elf_Internal_Rela
*free_relocs
= NULL
;
1335 Elf_Internal_Rela
*irel
, *irelend
;
1336 bfd_byte
*free_contents
= NULL
;
1337 Elf64_External_Sym
*extsyms
= NULL
;
1338 Elf64_External_Sym
*free_extsyms
= NULL
;
1339 struct alpha_elf_got_entry
**local_got_entries
;
1340 struct alpha_relax_info info
;
1342 /* We are not currently changing any sizes, so only one pass. */
1345 if (link_info
->relocateable
1346 || (sec
->flags
& SEC_RELOC
) == 0
1347 || sec
->reloc_count
== 0)
1350 /* If this is the first time we have been called for this section,
1351 initialize the cooked size. */
1352 if (sec
->_cooked_size
== 0)
1353 sec
->_cooked_size
= sec
->_raw_size
;
1355 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1356 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1358 /* Load the relocations for this section. */
1359 internal_relocs
= (_bfd_elf64_link_read_relocs
1360 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1361 link_info
->keep_memory
));
1362 if (internal_relocs
== NULL
)
1364 if (! link_info
->keep_memory
)
1365 free_relocs
= internal_relocs
;
1367 memset(&info
, 0, sizeof (info
));
1370 info
.link_info
= link_info
;
1371 info
.relocs
= internal_relocs
;
1372 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
1374 /* Find the GP for this object. */
1375 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
1378 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
1379 info
.gp
= _bfd_get_gp_value (info
.gotobj
);
1382 info
.gp
= (sgot
->output_section
->vma
1383 + sgot
->output_offset
1385 _bfd_set_gp_value (info
.gotobj
, info
.gp
);
1389 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1392 Elf_Internal_Sym isym
;
1393 struct alpha_elf_got_entry
*gotent
;
1395 if (ELF64_R_TYPE (irel
->r_info
) != (int) R_ALPHA_LITERAL
)
1398 /* Get the section contents. */
1399 if (info
.contents
== NULL
)
1401 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1402 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
1405 info
.contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
1406 if (info
.contents
== NULL
)
1408 free_contents
= info
.contents
;
1410 if (! bfd_get_section_contents (abfd
, sec
, info
.contents
,
1411 (file_ptr
) 0, sec
->_raw_size
))
1416 /* Read this BFD's symbols if we haven't done so already. */
1417 if (extsyms
== NULL
)
1419 if (symtab_hdr
->contents
!= NULL
)
1420 extsyms
= (Elf64_External_Sym
*) symtab_hdr
->contents
;
1423 extsyms
= ((Elf64_External_Sym
*)
1424 bfd_malloc (symtab_hdr
->sh_size
));
1425 if (extsyms
== NULL
)
1427 free_extsyms
= extsyms
;
1428 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1429 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
1430 != symtab_hdr
->sh_size
))
1435 /* Get the value of the symbol referred to by the reloc. */
1436 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1438 /* A local symbol. */
1439 bfd_elf64_swap_symbol_in (abfd
,
1440 extsyms
+ ELF64_R_SYM (irel
->r_info
),
1442 if (isym
.st_shndx
== SHN_UNDEF
)
1443 info
.tsec
= bfd_und_section_ptr
;
1444 else if (isym
.st_shndx
> 0 && isym
.st_shndx
< SHN_LORESERVE
)
1445 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
1446 else if (isym
.st_shndx
== SHN_ABS
)
1447 info
.tsec
= bfd_abs_section_ptr
;
1448 else if (isym
.st_shndx
== SHN_COMMON
)
1449 info
.tsec
= bfd_com_section_ptr
;
1451 continue; /* who knows. */
1454 info
.other
= isym
.st_other
;
1455 gotent
= local_got_entries
[ELF64_R_SYM(irel
->r_info
)];
1456 symval
= isym
.st_value
;
1461 struct alpha_elf_link_hash_entry
*h
;
1463 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1464 h
= alpha_elf_sym_hashes (abfd
)[indx
];
1465 BFD_ASSERT (h
!= NULL
);
1467 while (h
->root
.root
.type
== bfd_link_hash_indirect
1468 || h
->root
.root
.type
== bfd_link_hash_warning
)
1469 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1471 /* We can't do anthing with undefined or dynamic symbols. */
1472 if (h
->root
.root
.type
== bfd_link_hash_undefined
1473 || h
->root
.root
.type
== bfd_link_hash_undefweak
1474 || alpha_elf_dynamic_symbol_p (&h
->root
, link_info
))
1478 info
.tsec
= h
->root
.root
.u
.def
.section
;
1479 info
.other
= h
->root
.other
;
1480 gotent
= h
->got_entries
;
1481 symval
= h
->root
.root
.u
.def
.value
;
1484 /* Search for the got entry to be used by this relocation. */
1485 while (gotent
->gotobj
!= info
.gotobj
|| gotent
->addend
!= irel
->r_addend
)
1486 gotent
= gotent
->next
;
1487 info
.gotent
= gotent
;
1489 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
1490 symval
+= irel
->r_addend
;
1492 BFD_ASSERT(info
.gotent
!= NULL
);
1494 /* If there exist LITUSE relocations immediately following, this
1495 opens up all sorts of interesting optimizations, because we
1496 now know every location that this address load is used. */
1498 if (irel
+1 < irelend
&& ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
1500 irel
= elf64_alpha_relax_with_lituse (&info
, symval
, irel
, irelend
);
1506 if (!elf64_alpha_relax_without_lituse (&info
, symval
, irel
))
1511 if (!elf64_alpha_size_got_sections (abfd
, link_info
))
1514 if (info
.changed_relocs
)
1516 elf_section_data (sec
)->relocs
= internal_relocs
;
1518 else if (free_relocs
!= NULL
)
1523 if (info
.changed_contents
)
1525 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
1527 else if (free_contents
!= NULL
)
1529 if (! link_info
->keep_memory
)
1530 free (free_contents
);
1533 /* Cache the section contents for elf_link_input_bfd. */
1534 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
1538 if (free_extsyms
!= NULL
)
1540 if (! link_info
->keep_memory
)
1541 free (free_extsyms
);
1544 /* Cache the symbols for elf_link_input_bfd. */
1545 symtab_hdr
->contents
= extsyms
;
1549 *again
= info
.changed_contents
|| info
.changed_relocs
;
1554 if (free_relocs
!= NULL
)
1556 if (free_contents
!= NULL
)
1557 free (free_contents
);
1558 if (free_extsyms
!= NULL
)
1559 free (free_extsyms
);
1564 #define PLT_HEADER_SIZE 32
1565 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1566 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1567 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1568 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1570 #define PLT_ENTRY_SIZE 12
1571 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1572 #define PLT_ENTRY_WORD2 0
1573 #define PLT_ENTRY_WORD3 0
1575 #define MAX_GOT_ENTRIES (64*1024 / 8)
1577 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1579 /* Handle an Alpha specific section when reading an object file. This
1580 is called when elfcode.h finds a section with an unknown type.
1581 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1585 elf64_alpha_section_from_shdr (abfd
, hdr
, name
)
1587 Elf64_Internal_Shdr
*hdr
;
1592 /* There ought to be a place to keep ELF backend specific flags, but
1593 at the moment there isn't one. We just keep track of the
1594 sections by their name, instead. Fortunately, the ABI gives
1595 suggested names for all the MIPS specific sections, so we will
1596 probably get away with this. */
1597 switch (hdr
->sh_type
)
1599 case SHT_ALPHA_DEBUG
:
1600 if (strcmp (name
, ".mdebug") != 0)
1603 #ifdef ERIC_neverdef
1604 case SHT_ALPHA_REGINFO
:
1605 if (strcmp (name
, ".reginfo") != 0
1606 || hdr
->sh_size
!= sizeof (Elf64_External_RegInfo
))
1614 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1616 newsect
= hdr
->bfd_section
;
1618 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
1620 if (! bfd_set_section_flags (abfd
, newsect
,
1621 (bfd_get_section_flags (abfd
, newsect
)
1626 #ifdef ERIC_neverdef
1627 /* For a .reginfo section, set the gp value in the tdata information
1628 from the contents of this section. We need the gp value while
1629 processing relocs, so we just get it now. */
1630 if (hdr
->sh_type
== SHT_ALPHA_REGINFO
)
1632 Elf64_External_RegInfo ext
;
1635 if (! bfd_get_section_contents (abfd
, newsect
, (PTR
) &ext
,
1636 (file_ptr
) 0, sizeof ext
))
1638 bfd_alpha_elf64_swap_reginfo_in (abfd
, &ext
, &s
);
1639 elf_gp (abfd
) = s
.ri_gp_value
;
1646 /* Set the correct type for an Alpha ELF section. We do this by the
1647 section name, which is a hack, but ought to work. */
1650 elf64_alpha_fake_sections (abfd
, hdr
, sec
)
1652 Elf64_Internal_Shdr
*hdr
;
1655 register const char *name
;
1657 name
= bfd_get_section_name (abfd
, sec
);
1659 if (strcmp (name
, ".mdebug") == 0)
1661 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
1662 /* In a shared object on Irix 5.3, the .mdebug section has an
1663 entsize of 0. FIXME: Does this matter? */
1664 if ((abfd
->flags
& DYNAMIC
) != 0 )
1665 hdr
->sh_entsize
= 0;
1667 hdr
->sh_entsize
= 1;
1669 #ifdef ERIC_neverdef
1670 else if (strcmp (name
, ".reginfo") == 0)
1672 hdr
->sh_type
= SHT_ALPHA_REGINFO
;
1673 /* In a shared object on Irix 5.3, the .reginfo section has an
1674 entsize of 0x18. FIXME: Does this matter? */
1675 if ((abfd
->flags
& DYNAMIC
) != 0)
1676 hdr
->sh_entsize
= sizeof (Elf64_External_RegInfo
);
1678 hdr
->sh_entsize
= 1;
1680 /* Force the section size to the correct value, even if the
1681 linker thinks it is larger. The link routine below will only
1682 write out this much data for .reginfo. */
1683 hdr
->sh_size
= sec
->_raw_size
= sizeof (Elf64_External_RegInfo
);
1685 else if (strcmp (name
, ".hash") == 0
1686 || strcmp (name
, ".dynamic") == 0
1687 || strcmp (name
, ".dynstr") == 0)
1689 hdr
->sh_entsize
= 0;
1690 hdr
->sh_info
= SIZEOF_ALPHA_DYNSYM_SECNAMES
;
1693 else if (strcmp (name
, ".sdata") == 0
1694 || strcmp (name
, ".sbss") == 0
1695 || strcmp (name
, ".lit4") == 0
1696 || strcmp (name
, ".lit8") == 0)
1697 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
1702 /* Hook called by the linker routine which adds symbols from an object
1703 file. We use it to put .comm items in .sbss, and not .bss. */
1706 elf64_alpha_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1708 struct bfd_link_info
*info
;
1709 const Elf_Internal_Sym
*sym
;
1710 const char **namep ATTRIBUTE_UNUSED
;
1711 flagword
*flagsp ATTRIBUTE_UNUSED
;
1715 if (sym
->st_shndx
== SHN_COMMON
1716 && !info
->relocateable
1717 && sym
->st_size
<= elf_gp_size (abfd
))
1719 /* Common symbols less than or equal to -G nn bytes are
1720 automatically put into .sbss. */
1722 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1726 scomm
= bfd_make_section (abfd
, ".scommon");
1728 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1730 | SEC_LINKER_CREATED
)))
1735 *valp
= sym
->st_size
;
1741 /* Create the .got section. */
1744 elf64_alpha_create_got_section(abfd
, info
)
1746 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1750 if (bfd_get_section_by_name (abfd
, ".got"))
1753 s
= bfd_make_section (abfd
, ".got");
1755 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1758 | SEC_LINKER_CREATED
))
1759 || !bfd_set_section_alignment (abfd
, s
, 3))
1762 alpha_elf_tdata (abfd
)->got
= s
;
1767 /* Create all the dynamic sections. */
1770 elf64_alpha_create_dynamic_sections (abfd
, info
)
1772 struct bfd_link_info
*info
;
1775 struct elf_link_hash_entry
*h
;
1777 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1779 s
= bfd_make_section (abfd
, ".plt");
1781 || ! bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1784 | SEC_LINKER_CREATED
1786 || ! bfd_set_section_alignment (abfd
, s
, 3))
1789 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1792 if (! (_bfd_generic_link_add_one_symbol
1793 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
1794 (bfd_vma
) 0, (const char *) NULL
, false,
1795 get_elf_backend_data (abfd
)->collect
,
1796 (struct bfd_link_hash_entry
**) &h
)))
1798 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1799 h
->type
= STT_OBJECT
;
1802 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1805 s
= bfd_make_section (abfd
, ".rela.plt");
1807 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1810 | SEC_LINKER_CREATED
1812 || ! bfd_set_section_alignment (abfd
, s
, 3))
1815 /* We may or may not have created a .got section for this object, but
1816 we definitely havn't done the rest of the work. */
1818 if (!elf64_alpha_create_got_section (abfd
, info
))
1821 s
= bfd_make_section(abfd
, ".rela.got");
1823 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1826 | SEC_LINKER_CREATED
1828 || !bfd_set_section_alignment (abfd
, s
, 3))
1831 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1832 dynobj's .got section. We don't do this in the linker script
1833 because we don't want to define the symbol if we are not creating
1834 a global offset table. */
1836 if (!(_bfd_generic_link_add_one_symbol
1837 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
,
1838 alpha_elf_tdata(abfd
)->got
, (bfd_vma
) 0, (const char *) NULL
,
1839 false, get_elf_backend_data (abfd
)->collect
,
1840 (struct bfd_link_hash_entry
**) &h
)))
1842 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1843 h
->type
= STT_OBJECT
;
1846 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1849 elf_hash_table (info
)->hgot
= h
;
1854 /* Read ECOFF debugging information from a .mdebug section into a
1855 ecoff_debug_info structure. */
1858 elf64_alpha_read_ecoff_info (abfd
, section
, debug
)
1861 struct ecoff_debug_info
*debug
;
1864 const struct ecoff_debug_swap
*swap
;
1865 char *ext_hdr
= NULL
;
1867 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1868 memset (debug
, 0, sizeof (*debug
));
1870 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
1871 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1874 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
1875 swap
->external_hdr_size
)
1879 symhdr
= &debug
->symbolic_header
;
1880 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1882 /* The symbolic header contains absolute file offsets and sizes to
1884 #define READ(ptr, offset, count, size, type) \
1885 if (symhdr->count == 0) \
1886 debug->ptr = NULL; \
1889 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
1890 if (debug->ptr == NULL) \
1891 goto error_return; \
1892 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1893 || (bfd_read (debug->ptr, size, symhdr->count, \
1894 abfd) != size * symhdr->count)) \
1895 goto error_return; \
1898 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1899 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
1900 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
1901 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
1902 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
1903 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1905 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1906 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1907 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
1908 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
1909 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
1913 debug
->adjust
= NULL
;
1918 if (ext_hdr
!= NULL
)
1920 if (debug
->line
!= NULL
)
1922 if (debug
->external_dnr
!= NULL
)
1923 free (debug
->external_dnr
);
1924 if (debug
->external_pdr
!= NULL
)
1925 free (debug
->external_pdr
);
1926 if (debug
->external_sym
!= NULL
)
1927 free (debug
->external_sym
);
1928 if (debug
->external_opt
!= NULL
)
1929 free (debug
->external_opt
);
1930 if (debug
->external_aux
!= NULL
)
1931 free (debug
->external_aux
);
1932 if (debug
->ss
!= NULL
)
1934 if (debug
->ssext
!= NULL
)
1935 free (debug
->ssext
);
1936 if (debug
->external_fdr
!= NULL
)
1937 free (debug
->external_fdr
);
1938 if (debug
->external_rfd
!= NULL
)
1939 free (debug
->external_rfd
);
1940 if (debug
->external_ext
!= NULL
)
1941 free (debug
->external_ext
);
1945 /* Alpha ELF local labels start with '$'. */
1948 elf64_alpha_is_local_label_name (abfd
, name
)
1949 bfd
*abfd ATTRIBUTE_UNUSED
;
1952 return name
[0] == '$';
1955 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
1956 routine in order to handle the ECOFF debugging information. We
1957 still call this mips_elf_find_line because of the slot
1958 find_line_info in elf_obj_tdata is declared that way. */
1960 struct mips_elf_find_line
1962 struct ecoff_debug_info d
;
1963 struct ecoff_find_line i
;
1967 elf64_alpha_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
1968 functionname_ptr
, line_ptr
)
1973 const char **filename_ptr
;
1974 const char **functionname_ptr
;
1975 unsigned int *line_ptr
;
1979 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
1980 filename_ptr
, functionname_ptr
,
1982 &elf_tdata (abfd
)->dwarf2_find_line_info
))
1985 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
1989 struct mips_elf_find_line
*fi
;
1990 const struct ecoff_debug_swap
* const swap
=
1991 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1993 /* If we are called during a link, alpha_elf_final_link may have
1994 cleared the SEC_HAS_CONTENTS field. We force it back on here
1995 if appropriate (which it normally will be). */
1996 origflags
= msec
->flags
;
1997 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
1998 msec
->flags
|= SEC_HAS_CONTENTS
;
2000 fi
= elf_tdata (abfd
)->find_line_info
;
2003 bfd_size_type external_fdr_size
;
2006 struct fdr
*fdr_ptr
;
2008 fi
= ((struct mips_elf_find_line
*)
2009 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
2012 msec
->flags
= origflags
;
2016 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
2018 msec
->flags
= origflags
;
2022 /* Swap in the FDR information. */
2023 fi
->d
.fdr
= ((struct fdr
*)
2025 (fi
->d
.symbolic_header
.ifdMax
*
2026 sizeof (struct fdr
))));
2027 if (fi
->d
.fdr
== NULL
)
2029 msec
->flags
= origflags
;
2032 external_fdr_size
= swap
->external_fdr_size
;
2033 fdr_ptr
= fi
->d
.fdr
;
2034 fraw_src
= (char *) fi
->d
.external_fdr
;
2035 fraw_end
= (fraw_src
2036 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2037 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2038 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2040 elf_tdata (abfd
)->find_line_info
= fi
;
2042 /* Note that we don't bother to ever free this information.
2043 find_nearest_line is either called all the time, as in
2044 objdump -l, so the information should be saved, or it is
2045 rarely called, as in ld error messages, so the memory
2046 wasted is unimportant. Still, it would probably be a
2047 good idea for free_cached_info to throw it away. */
2050 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2051 &fi
->i
, filename_ptr
, functionname_ptr
,
2054 msec
->flags
= origflags
;
2058 msec
->flags
= origflags
;
2061 /* Fall back on the generic ELF find_nearest_line routine. */
2063 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2064 filename_ptr
, functionname_ptr
,
2068 /* Structure used to pass information to alpha_elf_output_extsym. */
2073 struct bfd_link_info
*info
;
2074 struct ecoff_debug_info
*debug
;
2075 const struct ecoff_debug_swap
*swap
;
2080 elf64_alpha_output_extsym (h
, data
)
2081 struct alpha_elf_link_hash_entry
*h
;
2084 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2086 asection
*sec
, *output_section
;
2088 if (h
->root
.indx
== -2)
2090 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2091 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2092 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2093 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2095 else if (einfo
->info
->strip
== strip_all
2096 || (einfo
->info
->strip
== strip_some
2097 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2098 h
->root
.root
.root
.string
,
2099 false, false) == NULL
))
2107 if (h
->esym
.ifd
== -2)
2110 h
->esym
.cobol_main
= 0;
2111 h
->esym
.weakext
= 0;
2112 h
->esym
.reserved
= 0;
2113 h
->esym
.ifd
= ifdNil
;
2114 h
->esym
.asym
.value
= 0;
2115 h
->esym
.asym
.st
= stGlobal
;
2117 if (h
->root
.root
.type
!= bfd_link_hash_defined
2118 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2119 h
->esym
.asym
.sc
= scAbs
;
2124 sec
= h
->root
.root
.u
.def
.section
;
2125 output_section
= sec
->output_section
;
2127 /* When making a shared library and symbol h is the one from
2128 the another shared library, OUTPUT_SECTION may be null. */
2129 if (output_section
== NULL
)
2130 h
->esym
.asym
.sc
= scUndefined
;
2133 name
= bfd_section_name (output_section
->owner
, output_section
);
2135 if (strcmp (name
, ".text") == 0)
2136 h
->esym
.asym
.sc
= scText
;
2137 else if (strcmp (name
, ".data") == 0)
2138 h
->esym
.asym
.sc
= scData
;
2139 else if (strcmp (name
, ".sdata") == 0)
2140 h
->esym
.asym
.sc
= scSData
;
2141 else if (strcmp (name
, ".rodata") == 0
2142 || strcmp (name
, ".rdata") == 0)
2143 h
->esym
.asym
.sc
= scRData
;
2144 else if (strcmp (name
, ".bss") == 0)
2145 h
->esym
.asym
.sc
= scBss
;
2146 else if (strcmp (name
, ".sbss") == 0)
2147 h
->esym
.asym
.sc
= scSBss
;
2148 else if (strcmp (name
, ".init") == 0)
2149 h
->esym
.asym
.sc
= scInit
;
2150 else if (strcmp (name
, ".fini") == 0)
2151 h
->esym
.asym
.sc
= scFini
;
2153 h
->esym
.asym
.sc
= scAbs
;
2157 h
->esym
.asym
.reserved
= 0;
2158 h
->esym
.asym
.index
= indexNil
;
2161 if (h
->root
.root
.type
== bfd_link_hash_common
)
2162 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2163 else if (h
->root
.root
.type
== bfd_link_hash_defined
2164 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2166 if (h
->esym
.asym
.sc
== scCommon
)
2167 h
->esym
.asym
.sc
= scBss
;
2168 else if (h
->esym
.asym
.sc
== scSCommon
)
2169 h
->esym
.asym
.sc
= scSBss
;
2171 sec
= h
->root
.root
.u
.def
.section
;
2172 output_section
= sec
->output_section
;
2173 if (output_section
!= NULL
)
2174 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2175 + sec
->output_offset
2176 + output_section
->vma
);
2178 h
->esym
.asym
.value
= 0;
2180 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2182 /* Set type and value for a symbol with a function stub. */
2183 h
->esym
.asym
.st
= stProc
;
2184 sec
= bfd_get_section_by_name (einfo
->abfd
, ".plt");
2186 h
->esym
.asym
.value
= 0;
2189 output_section
= sec
->output_section
;
2190 if (output_section
!= NULL
)
2191 h
->esym
.asym
.value
= (h
->root
.plt
.offset
2192 + sec
->output_offset
2193 + output_section
->vma
);
2195 h
->esym
.asym
.value
= 0;
2202 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2203 h
->root
.root
.root
.string
,
2206 einfo
->failed
= true;
2213 /* FIXME: Create a runtime procedure table from the .mdebug section.
2216 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2219 struct bfd_link_info *info;
2221 struct ecoff_debug_info *debug;
2224 /* Handle dynamic relocations when doing an Alpha ELF link. */
2227 elf64_alpha_check_relocs (abfd
, info
, sec
, relocs
)
2229 struct bfd_link_info
*info
;
2231 const Elf_Internal_Rela
*relocs
;
2235 const char *rel_sec_name
;
2236 Elf_Internal_Shdr
*symtab_hdr
;
2237 struct alpha_elf_link_hash_entry
**sym_hashes
;
2238 struct alpha_elf_got_entry
**local_got_entries
;
2239 const Elf_Internal_Rela
*rel
, *relend
;
2242 if (info
->relocateable
)
2245 dynobj
= elf_hash_table(info
)->dynobj
;
2247 elf_hash_table(info
)->dynobj
= dynobj
= abfd
;
2250 rel_sec_name
= NULL
;
2251 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2252 sym_hashes
= alpha_elf_sym_hashes(abfd
);
2253 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2256 relend
= relocs
+ sec
->reloc_count
;
2257 for (rel
= relocs
; rel
< relend
; ++rel
)
2259 unsigned long r_symndx
, r_type
;
2260 struct alpha_elf_link_hash_entry
*h
;
2262 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2263 if (r_symndx
< symtab_hdr
->sh_info
)
2267 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2269 while (h
->root
.root
.type
== bfd_link_hash_indirect
2270 || h
->root
.root
.type
== bfd_link_hash_warning
)
2271 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2273 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2275 r_type
= ELF64_R_TYPE (rel
->r_info
);
2279 case R_ALPHA_LITERAL
:
2281 struct alpha_elf_got_entry
*gotent
;
2286 /* Search for and possibly create a got entry. */
2287 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2288 if (gotent
->gotobj
== abfd
&&
2289 gotent
->addend
== rel
->r_addend
)
2294 gotent
= ((struct alpha_elf_got_entry
*)
2296 sizeof (struct alpha_elf_got_entry
)));
2300 gotent
->gotobj
= abfd
;
2301 gotent
->addend
= rel
->r_addend
;
2302 gotent
->got_offset
= -1;
2304 gotent
->use_count
= 1;
2306 gotent
->next
= h
->got_entries
;
2307 h
->got_entries
= gotent
;
2309 alpha_elf_tdata (abfd
)->total_got_entries
++;
2312 gotent
->use_count
+= 1;
2316 /* This is a local .got entry -- record for merge. */
2317 if (!local_got_entries
)
2320 size
= (symtab_hdr
->sh_info
2321 * sizeof (struct alpha_elf_got_entry
*));
2323 local_got_entries
= ((struct alpha_elf_got_entry
**)
2324 bfd_alloc (abfd
, size
));
2325 if (!local_got_entries
)
2328 memset (local_got_entries
, 0, size
);
2329 alpha_elf_tdata (abfd
)->local_got_entries
=
2333 for (gotent
= local_got_entries
[ELF64_R_SYM(rel
->r_info
)];
2334 gotent
!= NULL
&& gotent
->addend
!= rel
->r_addend
;
2335 gotent
= gotent
->next
)
2339 gotent
= ((struct alpha_elf_got_entry
*)
2341 sizeof (struct alpha_elf_got_entry
)));
2345 gotent
->gotobj
= abfd
;
2346 gotent
->addend
= rel
->r_addend
;
2347 gotent
->got_offset
= -1;
2349 gotent
->use_count
= 1;
2351 gotent
->next
= local_got_entries
[ELF64_R_SYM(rel
->r_info
)];
2352 local_got_entries
[ELF64_R_SYM(rel
->r_info
)] = gotent
;
2354 alpha_elf_tdata(abfd
)->total_got_entries
++;
2355 alpha_elf_tdata(abfd
)->n_local_got_entries
++;
2358 gotent
->use_count
+= 1;
2361 /* Remember how this literal is used from its LITUSEs.
2362 This will be important when it comes to decide if we can
2363 create a .plt entry for a function symbol. */
2365 && ELF64_R_TYPE (rel
[1].r_info
) == R_ALPHA_LITUSE
)
2370 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 3)
2371 flags
|= 1 << rel
->r_addend
;
2373 while (rel
+1 < relend
&&
2374 ELF64_R_TYPE (rel
[1].r_info
) == R_ALPHA_LITUSE
);
2378 /* No LITUSEs -- presumably the address is not being
2379 loaded for nothing. */
2380 flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
2383 gotent
->flags
|= flags
;
2386 /* Make a guess as to whether a .plt entry will be needed. */
2387 if ((h
->flags
|= flags
) == ALPHA_ELF_LINK_HASH_LU_FUNC
)
2388 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2390 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2395 case R_ALPHA_GPDISP
:
2396 case R_ALPHA_GPREL16
:
2397 case R_ALPHA_GPREL32
:
2398 case R_ALPHA_GPRELHIGH
:
2399 case R_ALPHA_GPRELLOW
:
2400 /* We don't actually use the .got here, but the sections must
2401 be created before the linker maps input sections to output
2405 if (!elf64_alpha_create_got_section (abfd
, info
))
2408 /* Make sure the object's gotobj is set to itself so
2409 that we default to every object with its own .got.
2410 We'll merge .gots later once we've collected each
2412 alpha_elf_tdata(abfd
)->gotobj
= abfd
;
2418 case R_ALPHA_SREL16
:
2419 case R_ALPHA_SREL32
:
2420 case R_ALPHA_SREL64
:
2425 case R_ALPHA_REFLONG
:
2426 case R_ALPHA_REFQUAD
:
2427 if (rel_sec_name
== NULL
)
2429 rel_sec_name
= (bfd_elf_string_from_elf_section
2430 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2431 elf_section_data(sec
)->rel_hdr
.sh_name
));
2432 if (rel_sec_name
== NULL
)
2435 BFD_ASSERT (strncmp (rel_sec_name
, ".rela", 5) == 0
2436 && strcmp (bfd_get_section_name (abfd
, sec
),
2437 rel_sec_name
+5) == 0);
2440 /* We need to create the section here now whether we eventually
2441 use it or not so that it gets mapped to an output section by
2442 the linker. If not used, we'll kill it in
2443 size_dynamic_sections. */
2446 sreloc
= bfd_get_section_by_name (dynobj
, rel_sec_name
);
2449 sreloc
= bfd_make_section (dynobj
, rel_sec_name
);
2451 || !bfd_set_section_flags (dynobj
, sreloc
,
2458 | SEC_LINKER_CREATED
2460 || !bfd_set_section_alignment (dynobj
, sreloc
, 3))
2467 /* Since we havn't seen all of the input symbols yet, we
2468 don't know whether we'll actually need a dynamic relocation
2469 entry for this reloc. So make a record of it. Once we
2470 find out if this thing needs dynamic relocation we'll
2471 expand the relocation sections by the appropriate amount. */
2473 struct alpha_elf_reloc_entry
*rent
;
2475 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
2476 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
2481 rent
= ((struct alpha_elf_reloc_entry
*)
2483 sizeof (struct alpha_elf_reloc_entry
)));
2487 rent
->srel
= sreloc
;
2488 rent
->rtype
= r_type
;
2490 rent
->reltext
= (sec
->flags
& SEC_READONLY
) != 0;
2492 rent
->next
= h
->reloc_entries
;
2493 h
->reloc_entries
= rent
;
2498 else if (info
->shared
&& (sec
->flags
& SEC_ALLOC
))
2500 /* If this is a shared library, and the section is to be
2501 loaded into memory, we need a RELATIVE reloc. */
2502 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
2503 if (sec
->flags
& SEC_READONLY
)
2504 info
->flags
|= DF_TEXTREL
;
2513 /* Adjust a symbol defined by a dynamic object and referenced by a
2514 regular object. The current definition is in some section of the
2515 dynamic object, but we're not including those sections. We have to
2516 change the definition to something the rest of the link can
2520 elf64_alpha_adjust_dynamic_symbol (info
, h
)
2521 struct bfd_link_info
*info
;
2522 struct elf_link_hash_entry
*h
;
2526 struct alpha_elf_link_hash_entry
*ah
;
2528 dynobj
= elf_hash_table(info
)->dynobj
;
2529 ah
= (struct alpha_elf_link_hash_entry
*)h
;
2531 /* Now that we've seen all of the input symbols, finalize our decision
2532 about whether this symbol should get a .plt entry. */
2534 if (h
->root
.type
!= bfd_link_hash_undefweak
2535 && alpha_elf_dynamic_symbol_p (h
, info
)
2536 && ((h
->type
== STT_FUNC
2537 && !(ah
->flags
& ALPHA_ELF_LINK_HASH_LU_ADDR
))
2538 || (h
->type
== STT_NOTYPE
2539 && ah
->flags
== ALPHA_ELF_LINK_HASH_LU_FUNC
))
2540 /* Don't prevent otherwise valid programs from linking by attempting
2541 to create a new .got entry somewhere. A Correct Solution would be
2542 to add a new .got section to a new object file and let it be merged
2543 somewhere later. But for now don't bother. */
2546 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2548 s
= bfd_get_section_by_name(dynobj
, ".plt");
2549 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
2552 /* The first bit of the .plt is reserved. */
2553 if (s
->_raw_size
== 0)
2554 s
->_raw_size
= PLT_HEADER_SIZE
;
2556 h
->plt
.offset
= s
->_raw_size
;
2557 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2559 /* If this symbol is not defined in a regular file, and we are not
2560 generating a shared library, then set the symbol to the location
2561 in the .plt. This is required to make function pointers compare
2562 equal between the normal executable and the shared library. */
2564 && h
->root
.type
!= bfd_link_hash_defweak
)
2566 h
->root
.u
.def
.section
= s
;
2567 h
->root
.u
.def
.value
= h
->plt
.offset
;
2570 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2571 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2572 BFD_ASSERT (s
!= NULL
);
2573 s
->_raw_size
+= sizeof (Elf64_External_Rela
);
2578 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2580 /* If this is a weak symbol, and there is a real definition, the
2581 processor independent code will have arranged for us to see the
2582 real definition first, and we can just use the same value. */
2583 if (h
->weakdef
!= NULL
)
2585 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2586 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2587 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2588 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2592 /* This is a reference to a symbol defined by a dynamic object which
2593 is not a function. The Alpha, since it uses .got entries for all
2594 symbols even in regular objects, does not need the hackery of a
2595 .dynbss section and COPY dynamic relocations. */
2600 /* Symbol versioning can create new symbols, and make our old symbols
2601 indirect to the new ones. Consolidate the got and reloc information
2602 in these situations. */
2605 elf64_alpha_merge_ind_symbols (hi
, dummy
)
2606 struct alpha_elf_link_hash_entry
*hi
;
2607 PTR dummy ATTRIBUTE_UNUSED
;
2609 struct alpha_elf_link_hash_entry
*hs
;
2611 if (hi
->root
.root
.type
!= bfd_link_hash_indirect
)
2615 hs
= (struct alpha_elf_link_hash_entry
*)hs
->root
.root
.u
.i
.link
;
2616 } while (hs
->root
.root
.type
== bfd_link_hash_indirect
);
2618 /* Merge the flags. Whee. */
2620 hs
->flags
|= hi
->flags
;
2622 /* Merge the .got entries. Cannibalize the old symbol's list in
2623 doing so, since we don't need it anymore. */
2625 if (hs
->got_entries
== NULL
)
2626 hs
->got_entries
= hi
->got_entries
;
2629 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
2631 gsh
= hs
->got_entries
;
2632 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
2635 for (gs
= gsh
; gs
; gs
= gs
->next
)
2636 if (gi
->gotobj
== gs
->gotobj
&& gi
->addend
== gs
->addend
)
2638 gi
->next
= hs
->got_entries
;
2639 hs
->got_entries
= gi
;
2643 hi
->got_entries
= NULL
;
2645 /* And similar for the reloc entries. */
2647 if (hs
->reloc_entries
== NULL
)
2648 hs
->reloc_entries
= hi
->reloc_entries
;
2651 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
2653 rsh
= hs
->reloc_entries
;
2654 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
2657 for (rs
= rsh
; rs
; rs
= rs
->next
)
2658 if (ri
->rtype
== rs
->rtype
)
2660 rs
->count
+= ri
->count
;
2663 ri
->next
= hs
->reloc_entries
;
2664 hs
->reloc_entries
= ri
;
2668 hi
->reloc_entries
= NULL
;
2673 /* Is it possible to merge two object file's .got tables? */
2676 elf64_alpha_can_merge_gots (a
, b
)
2679 int total
= alpha_elf_tdata (a
)->total_got_entries
;
2682 /* Trivial quick fallout test. */
2683 if (total
+ alpha_elf_tdata (b
)->total_got_entries
<= MAX_GOT_ENTRIES
)
2686 /* By their nature, local .got entries cannot be merged. */
2687 if ((total
+= alpha_elf_tdata (b
)->n_local_got_entries
) > MAX_GOT_ENTRIES
)
2690 /* Failing the common trivial comparison, we must effectively
2691 perform the merge. Not actually performing the merge means that
2692 we don't have to store undo information in case we fail. */
2693 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2695 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
2696 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2699 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
2700 for (i
= 0; i
< n
; ++i
)
2702 struct alpha_elf_got_entry
*ae
, *be
;
2703 struct alpha_elf_link_hash_entry
*h
;
2706 while (h
->root
.root
.type
== bfd_link_hash_indirect
2707 || h
->root
.root
.type
== bfd_link_hash_warning
)
2708 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2710 for (be
= h
->got_entries
; be
; be
= be
->next
)
2712 if (be
->use_count
== 0)
2714 if (be
->gotobj
!= b
)
2717 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
2718 if (ae
->gotobj
== a
&& ae
->addend
== be
->addend
)
2721 if (++total
> MAX_GOT_ENTRIES
)
2731 /* Actually merge two .got tables. */
2734 elf64_alpha_merge_gots (a
, b
)
2737 int total
= alpha_elf_tdata (a
)->total_got_entries
;
2740 /* Remember local expansion. */
2742 int e
= alpha_elf_tdata (b
)->n_local_got_entries
;
2744 alpha_elf_tdata (a
)->n_local_got_entries
+= e
;
2747 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2749 struct alpha_elf_got_entry
**local_got_entries
;
2750 struct alpha_elf_link_hash_entry
**hashes
;
2751 Elf_Internal_Shdr
*symtab_hdr
;
2754 /* Let the local .got entries know they are part of a new subsegment. */
2755 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
2756 if (local_got_entries
)
2758 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
2759 for (i
= 0; i
< n
; ++i
)
2761 struct alpha_elf_got_entry
*ent
;
2762 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
2767 /* Merge the global .got entries. */
2768 hashes
= alpha_elf_sym_hashes (bsub
);
2769 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2771 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
2772 for (i
= 0; i
< n
; ++i
)
2774 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
2775 struct alpha_elf_link_hash_entry
*h
;
2778 while (h
->root
.root
.type
== bfd_link_hash_indirect
2779 || h
->root
.root
.type
== bfd_link_hash_warning
)
2780 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2782 start
= &h
->got_entries
;
2783 for (pbe
= start
, be
= *start
; be
; pbe
= &be
->next
, be
= be
->next
)
2785 if (be
->use_count
== 0)
2790 if (be
->gotobj
!= b
)
2793 for (ae
= *start
; ae
; ae
= ae
->next
)
2794 if (ae
->gotobj
== a
&& ae
->addend
== be
->addend
)
2796 ae
->flags
|= be
->flags
;
2797 ae
->use_count
+= be
->use_count
;
2808 alpha_elf_tdata (bsub
)->gotobj
= a
;
2810 alpha_elf_tdata (a
)->total_got_entries
= total
;
2812 /* Merge the two in_got chains. */
2817 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
2820 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
2824 /* Calculate the offsets for the got entries. */
2827 elf64_alpha_calc_got_offsets_for_symbol (h
, arg
)
2828 struct alpha_elf_link_hash_entry
*h
;
2829 PTR arg ATTRIBUTE_UNUSED
;
2831 struct alpha_elf_got_entry
*gotent
;
2833 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2834 if (gotent
->use_count
> 0)
2837 = &alpha_elf_tdata (gotent
->gotobj
)->got
->_raw_size
;
2839 gotent
->got_offset
= *plge
;
2847 elf64_alpha_calc_got_offsets (info
)
2848 struct bfd_link_info
*info
;
2850 bfd
*i
, *got_list
= alpha_elf_hash_table(info
)->got_list
;
2852 /* First, zero out the .got sizes, as we may be recalculating the
2853 .got after optimizing it. */
2854 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2855 alpha_elf_tdata(i
)->got
->_raw_size
= 0;
2857 /* Next, fill in the offsets for all the global entries. */
2858 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
2859 elf64_alpha_calc_got_offsets_for_symbol
,
2862 /* Finally, fill in the offsets for the local entries. */
2863 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2865 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->_raw_size
;
2868 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
2870 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
2873 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
2874 if (!local_got_entries
)
2877 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
2878 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
2879 if (gotent
->use_count
> 0)
2881 gotent
->got_offset
= got_offset
;
2886 alpha_elf_tdata(i
)->got
->_raw_size
= got_offset
;
2887 alpha_elf_tdata(i
)->got
->_cooked_size
= got_offset
;
2891 /* Constructs the gots. */
2894 elf64_alpha_size_got_sections (output_bfd
, info
)
2895 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2896 struct bfd_link_info
*info
;
2898 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
2899 int something_changed
= 0;
2901 got_list
= alpha_elf_hash_table (info
)->got_list
;
2903 /* On the first time through, pretend we have an existing got list
2904 consisting of all of the input files. */
2905 if (got_list
== NULL
)
2907 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
2909 bfd
*this_got
= alpha_elf_tdata (i
)->gotobj
;
2910 if (this_got
== NULL
)
2913 /* We are assuming no merging has yet ocurred. */
2914 BFD_ASSERT (this_got
== i
);
2916 if (alpha_elf_tdata (this_got
)->total_got_entries
> MAX_GOT_ENTRIES
)
2918 /* Yikes! A single object file has too many entries. */
2919 (*_bfd_error_handler
)
2920 (_("%s: .got subsegment exceeds 64K (size %d)"),
2921 bfd_get_filename (i
),
2922 alpha_elf_tdata (this_got
)->total_got_entries
* 8);
2926 if (got_list
== NULL
)
2927 got_list
= this_got
;
2929 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
2930 cur_got_obj
= this_got
;
2933 /* Strange degenerate case of no got references. */
2934 if (got_list
== NULL
)
2937 alpha_elf_hash_table (info
)->got_list
= got_list
;
2939 /* Force got offsets to be recalculated. */
2940 something_changed
= 1;
2943 cur_got_obj
= got_list
;
2944 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
2947 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
2949 elf64_alpha_merge_gots (cur_got_obj
, i
);
2950 i
= alpha_elf_tdata(i
)->got_link_next
;
2951 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
2952 something_changed
= 1;
2957 i
= alpha_elf_tdata(i
)->got_link_next
;
2961 /* Once the gots have been merged, fill in the got offsets for
2962 everything therein. */
2963 if (1 || something_changed
)
2964 elf64_alpha_calc_got_offsets (info
);
2970 elf64_alpha_always_size_sections (output_bfd
, info
)
2972 struct bfd_link_info
*info
;
2976 if (info
->relocateable
)
2979 /* First, take care of the indirect symbols created by versioning. */
2980 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
2981 elf64_alpha_merge_ind_symbols
,
2984 if (!elf64_alpha_size_got_sections (output_bfd
, info
))
2987 /* Allocate space for all of the .got subsections. */
2988 i
= alpha_elf_hash_table (info
)->got_list
;
2989 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2991 asection
*s
= alpha_elf_tdata(i
)->got
;
2992 if (s
->_raw_size
> 0)
2994 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->_raw_size
);
2995 if (s
->contents
== NULL
)
3003 /* Work out the sizes of the dynamic relocation entries. */
3006 elf64_alpha_calc_dynrel_sizes (h
, info
)
3007 struct alpha_elf_link_hash_entry
*h
;
3008 struct bfd_link_info
*info
;
3010 /* If the symbol was defined as a common symbol in a regular object
3011 file, and there was no definition in any dynamic object, then the
3012 linker will have allocated space for the symbol in a common
3013 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3014 set. This is done for dynamic symbols in
3015 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3016 symbols, somehow. */
3017 if (((h
->root
.elf_link_hash_flags
3018 & (ELF_LINK_HASH_DEF_REGULAR
3019 | ELF_LINK_HASH_REF_REGULAR
3020 | ELF_LINK_HASH_DEF_DYNAMIC
))
3021 == ELF_LINK_HASH_REF_REGULAR
)
3022 && (h
->root
.root
.type
== bfd_link_hash_defined
3023 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3024 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3026 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3029 /* If the symbol is dynamic, we'll need all the relocations in their
3030 natural form. If this is a shared object, and it has been forced
3031 local, we'll need the same number of RELATIVE relocations. */
3033 if (alpha_elf_dynamic_symbol_p (&h
->root
, info
) || info
->shared
)
3035 struct alpha_elf_reloc_entry
*relent
;
3037 struct alpha_elf_got_entry
*gotent
;
3038 bfd_size_type count
;
3041 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
3042 if (relent
->rtype
== R_ALPHA_REFLONG
3043 || relent
->rtype
== R_ALPHA_REFQUAD
)
3045 relent
->srel
->_raw_size
+=
3046 sizeof (Elf64_External_Rela
) * relent
->count
;
3047 if (relent
->reltext
)
3048 info
->flags
|= DT_TEXTREL
;
3051 dynobj
= elf_hash_table(info
)->dynobj
;
3054 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3057 /* If we are using a .plt entry, subtract one, as the first
3058 reference uses a .rela.plt entry instead. */
3059 if (h
->root
.plt
.offset
!= MINUS_ONE
)
3064 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3065 BFD_ASSERT (srel
!= NULL
);
3066 srel
->_raw_size
+= sizeof (Elf64_External_Rela
) * count
;
3073 /* Set the sizes of the dynamic sections. */
3076 elf64_alpha_size_dynamic_sections (output_bfd
, info
)
3077 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3078 struct bfd_link_info
*info
;
3084 dynobj
= elf_hash_table(info
)->dynobj
;
3085 BFD_ASSERT(dynobj
!= NULL
);
3087 if (elf_hash_table (info
)->dynamic_sections_created
)
3089 /* Set the contents of the .interp section to the interpreter. */
3092 s
= bfd_get_section_by_name (dynobj
, ".interp");
3093 BFD_ASSERT (s
!= NULL
);
3094 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3095 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3098 /* Now that we've seen all of the input files, we can decide which
3099 symbols need dynamic relocation entries and which don't. We've
3100 collected information in check_relocs that we can now apply to
3101 size the dynamic relocation sections. */
3102 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3103 elf64_alpha_calc_dynrel_sizes
,
3106 /* When building shared libraries, each local .got entry needs a
3112 bfd_size_type count
;
3114 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3115 BFD_ASSERT (srel
!= NULL
);
3117 for (i
= alpha_elf_hash_table(info
)->got_list
, count
= 0;
3119 i
= alpha_elf_tdata(i
)->got_link_next
)
3120 count
+= alpha_elf_tdata(i
)->n_local_got_entries
;
3122 srel
->_raw_size
+= count
* sizeof (Elf64_External_Rela
);
3125 /* else we're not dynamic and by definition we don't need such things. */
3127 /* The check_relocs and adjust_dynamic_symbol entry points have
3128 determined the sizes of the various dynamic sections. Allocate
3131 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3136 if (!(s
->flags
& SEC_LINKER_CREATED
))
3139 /* It's OK to base decisions on the section name, because none
3140 of the dynobj section names depend upon the input files. */
3141 name
= bfd_get_section_name (dynobj
, s
);
3143 /* If we don't need this section, strip it from the output file.
3144 This is to handle .rela.bss and .rela.plt. We must create it
3145 in create_dynamic_sections, because it must be created before
3146 the linker maps input sections to output sections. The
3147 linker does that before adjust_dynamic_symbol is called, and
3148 it is that function which decides whether anything needs to
3149 go into these sections. */
3153 if (strncmp (name
, ".rela", 5) == 0)
3155 strip
= (s
->_raw_size
== 0);
3159 if (strcmp(name
, ".rela.plt") == 0)
3162 /* We use the reloc_count field as a counter if we need
3163 to copy relocs into the output file. */
3167 else if (strcmp (name
, ".plt") != 0)
3169 /* It's not one of our dynamic sections, so don't allocate space. */
3174 _bfd_strip_section_from_output (info
, s
);
3177 /* Allocate memory for the section contents. */
3178 s
->contents
= (bfd_byte
*) bfd_zalloc(dynobj
, s
->_raw_size
);
3179 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3184 if (elf_hash_table (info
)->dynamic_sections_created
)
3186 /* Add some entries to the .dynamic section. We fill in the
3187 values later, in elf64_alpha_finish_dynamic_sections, but we
3188 must add the entries now so that we get the correct size for
3189 the .dynamic section. The DT_DEBUG entry is filled in by the
3190 dynamic linker and used by the debugger. */
3193 if (!bfd_elf64_add_dynamic_entry (info
, DT_DEBUG
, 0))
3197 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTGOT
, 0))
3202 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
3203 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
3204 || ! bfd_elf64_add_dynamic_entry (info
, DT_JMPREL
, 0))
3208 if (! bfd_elf64_add_dynamic_entry (info
, DT_RELA
, 0)
3209 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELASZ
, 0)
3210 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELAENT
,
3211 sizeof (Elf64_External_Rela
)))
3214 if (info
->flags
& DF_TEXTREL
)
3216 if (! bfd_elf64_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3224 /* Relocate an Alpha ELF section. */
3227 elf64_alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3228 contents
, relocs
, local_syms
, local_sections
)
3230 struct bfd_link_info
*info
;
3232 asection
*input_section
;
3234 Elf_Internal_Rela
*relocs
;
3235 Elf_Internal_Sym
*local_syms
;
3236 asection
**local_sections
;
3238 Elf_Internal_Shdr
*symtab_hdr
;
3239 Elf_Internal_Rela
*rel
;
3240 Elf_Internal_Rela
*relend
;
3241 asection
*sec
, *sgot
, *srel
, *srelgot
;
3242 bfd
*dynobj
, *gotobj
;
3245 srelgot
= srel
= NULL
;
3246 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3247 dynobj
= elf_hash_table (info
)->dynobj
;
3250 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
3253 /* Find the gp value for this input bfd. */
3256 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
3259 sgot
= alpha_elf_tdata (gotobj
)->got
;
3260 gp
= _bfd_get_gp_value (gotobj
);
3263 gp
= (sgot
->output_section
->vma
3264 + sgot
->output_offset
3266 _bfd_set_gp_value (gotobj
, gp
);
3271 relend
= relocs
+ input_section
->reloc_count
;
3272 for (; rel
< relend
; rel
++)
3275 reloc_howto_type
*howto
;
3276 unsigned long r_symndx
;
3277 struct alpha_elf_link_hash_entry
*h
;
3278 Elf_Internal_Sym
*sym
;
3280 bfd_signed_vma addend
;
3281 bfd_reloc_status_type r
;
3283 r_type
= ELF64_R_TYPE(rel
->r_info
);
3284 if (r_type
< 0 || r_type
>= (int) R_ALPHA_max
)
3286 bfd_set_error (bfd_error_bad_value
);
3289 howto
= elf64_alpha_howto_table
+ r_type
;
3291 r_symndx
= ELF64_R_SYM(rel
->r_info
);
3293 if (info
->relocateable
)
3295 /* This is a relocateable link. We don't have to change
3296 anything, unless the reloc is against a section symbol,
3297 in which case we have to adjust according to where the
3298 section symbol winds up in the output section. */
3300 /* The symbol associated with GPDISP and LITUSE is
3301 immaterial. Only the addend is significant. */
3302 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
3305 if (r_symndx
< symtab_hdr
->sh_info
)
3307 sym
= local_syms
+ r_symndx
;
3308 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
3310 sec
= local_sections
[r_symndx
];
3311 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
3318 /* This is a final link. */
3324 if (r_symndx
< symtab_hdr
->sh_info
)
3326 sym
= local_syms
+ r_symndx
;
3327 sec
= local_sections
[r_symndx
];
3328 relocation
= (sec
->output_section
->vma
3329 + sec
->output_offset
3334 h
= alpha_elf_sym_hashes (input_bfd
)[r_symndx
- symtab_hdr
->sh_info
];
3336 while (h
->root
.root
.type
== bfd_link_hash_indirect
3337 || h
->root
.root
.type
== bfd_link_hash_warning
)
3338 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3340 if (h
->root
.root
.type
== bfd_link_hash_defined
3341 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3343 sec
= h
->root
.root
.u
.def
.section
;
3346 if ((r_type
== R_ALPHA_LITERAL
3347 && elf_hash_table(info
)->dynamic_sections_created
3350 || !(h
->root
.elf_link_hash_flags
3351 & ELF_LINK_HASH_DEF_REGULAR
)))
3354 || !(h
->root
.elf_link_hash_flags
3355 & ELF_LINK_HASH_DEF_REGULAR
))
3356 && (input_section
->flags
& SEC_ALLOC
)
3357 && (r_type
== R_ALPHA_REFLONG
3358 || r_type
== R_ALPHA_REFQUAD
3359 || r_type
== R_ALPHA_LITERAL
)))
3361 /* In these cases, we don't need the relocation value.
3362 We check specially because in some obscure cases
3363 sec->output_section will be NULL. */
3367 /* FIXME: Are not these obscure cases simply bugs? Let's
3368 get something working and come back to this. */
3369 if (sec
->output_section
== NULL
)
3371 #endif /* rth_notdef */
3374 relocation
= (h
->root
.root
.u
.def
.value
3375 + sec
->output_section
->vma
3376 + sec
->output_offset
);
3379 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3381 else if (info
->shared
&& !info
->symbolic
3382 && !info
->no_undefined
3383 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3387 if (!((*info
->callbacks
->undefined_symbol
)
3388 (info
, h
->root
.root
.root
.string
, input_bfd
,
3389 input_section
, rel
->r_offset
,
3390 (!info
->shared
|| info
->no_undefined
3391 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3396 addend
= rel
->r_addend
;
3400 case R_ALPHA_GPDISP
:
3402 bfd_byte
*p_ldah
, *p_lda
;
3404 BFD_ASSERT(gp
!= 0);
3406 relocation
= (input_section
->output_section
->vma
3407 + input_section
->output_offset
3410 p_ldah
= contents
+ rel
->r_offset
- input_section
->vma
;
3411 p_lda
= p_ldah
+ rel
->r_addend
;
3413 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- relocation
,
3418 case R_ALPHA_LITERAL
:
3420 struct alpha_elf_got_entry
*gotent
;
3421 boolean dynamic_symbol
;
3423 BFD_ASSERT(sgot
!= NULL
);
3424 BFD_ASSERT(gp
!= 0);
3428 gotent
= h
->got_entries
;
3429 dynamic_symbol
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3433 gotent
= (alpha_elf_tdata(input_bfd
)->
3434 local_got_entries
[r_symndx
]);
3435 dynamic_symbol
= false;
3438 BFD_ASSERT(gotent
!= NULL
);
3440 while (gotent
->gotobj
!= gotobj
|| gotent
->addend
!= addend
)
3441 gotent
= gotent
->next
;
3443 BFD_ASSERT(gotent
->use_count
>= 1);
3445 /* Initialize the .got entry's value. */
3446 if (!(gotent
->flags
& ALPHA_ELF_GOT_ENTRY_RELOCS_DONE
))
3448 bfd_put_64 (output_bfd
, relocation
+addend
,
3449 sgot
->contents
+ gotent
->got_offset
);
3451 /* If the symbol has been forced local, output a
3452 RELATIVE reloc, otherwise it will be handled in
3453 finish_dynamic_symbol. */
3454 if (info
->shared
&& !dynamic_symbol
)
3456 Elf_Internal_Rela outrel
;
3458 BFD_ASSERT(srelgot
!= NULL
);
3460 outrel
.r_offset
= (sgot
->output_section
->vma
3461 + sgot
->output_offset
3462 + gotent
->got_offset
);
3463 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
3464 outrel
.r_addend
= relocation
+addend
;
3466 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3467 ((Elf64_External_Rela
*)
3469 + srelgot
->reloc_count
++);
3470 BFD_ASSERT (sizeof (Elf64_External_Rela
)
3471 * srelgot
->reloc_count
3472 <= srelgot
->_cooked_size
);
3475 gotent
->flags
|= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE
;
3478 /* Figure the gprel relocation. */
3480 relocation
= (sgot
->output_section
->vma
3481 + sgot
->output_offset
3482 + gotent
->got_offset
);
3485 /* overflow handled by _bfd_final_link_relocate */
3488 case R_ALPHA_GPREL16
:
3489 case R_ALPHA_GPREL32
:
3490 case R_ALPHA_GPRELLOW
:
3491 BFD_ASSERT(gp
!= 0);
3495 case R_ALPHA_GPRELHIGH
:
3496 BFD_ASSERT(gp
!= 0);
3498 relocation
+= addend
;
3500 relocation
= (((bfd_signed_vma
) relocation
>> 16)
3501 + ((relocation
>> 15) & 1));
3504 case R_ALPHA_BRADDR
:
3506 /* The regular PC-relative stuff measures from the start of
3507 the instruction rather than the end. */
3511 case R_ALPHA_REFLONG
:
3512 case R_ALPHA_REFQUAD
:
3514 Elf_Internal_Rela outrel
;
3517 /* Careful here to remember RELATIVE relocations for global
3518 variables for symbolic shared objects. */
3520 if (h
&& alpha_elf_dynamic_symbol_p (&h
->root
, info
))
3522 BFD_ASSERT(h
->root
.dynindx
!= -1);
3523 outrel
.r_info
= ELF64_R_INFO(h
->root
.dynindx
, r_type
);
3524 outrel
.r_addend
= addend
;
3525 addend
= 0, relocation
= 0;
3527 else if (info
->shared
&& (input_section
->flags
& SEC_ALLOC
))
3529 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
3530 outrel
.r_addend
= relocation
+ addend
;
3539 name
= (bfd_elf_string_from_elf_section
3540 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
3541 elf_section_data(input_section
)->rel_hdr
.sh_name
));
3542 BFD_ASSERT(name
!= NULL
);
3544 srel
= bfd_get_section_by_name (dynobj
, name
);
3545 BFD_ASSERT(srel
!= NULL
);
3550 if (elf_section_data (input_section
)->stab_info
== NULL
)
3551 outrel
.r_offset
= rel
->r_offset
;
3556 off
= (_bfd_stab_section_offset
3557 (output_bfd
, &elf_hash_table (info
)->stab_info
,
3559 &elf_section_data (input_section
)->stab_info
,
3561 if (off
== (bfd_vma
) -1)
3563 outrel
.r_offset
= off
;
3567 outrel
.r_offset
+= (input_section
->output_section
->vma
3568 + input_section
->output_offset
);
3570 memset (&outrel
, 0, sizeof outrel
);
3572 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3573 ((Elf64_External_Rela
*)
3575 + srel
->reloc_count
++);
3576 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
3577 <= srel
->_cooked_size
);
3583 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3584 contents
, rel
->r_offset
, relocation
,
3594 case bfd_reloc_overflow
:
3599 name
= h
->root
.root
.root
.string
;
3602 name
= (bfd_elf_string_from_elf_section
3603 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
3607 name
= bfd_section_name (input_bfd
, sec
);
3609 if (! ((*info
->callbacks
->reloc_overflow
)
3610 (info
, name
, howto
->name
, (bfd_vma
) 0,
3611 input_bfd
, input_section
, rel
->r_offset
)))
3617 case bfd_reloc_outofrange
:
3625 /* Finish up dynamic symbol handling. We set the contents of various
3626 dynamic sections here. */
3629 elf64_alpha_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3631 struct bfd_link_info
*info
;
3632 struct elf_link_hash_entry
*h
;
3633 Elf_Internal_Sym
*sym
;
3635 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
3637 if (h
->plt
.offset
!= MINUS_ONE
)
3639 /* Fill in the .plt entry for this symbol. */
3640 asection
*splt
, *sgot
, *srel
;
3641 Elf_Internal_Rela outrel
;
3642 bfd_vma got_addr
, plt_addr
;
3644 struct alpha_elf_got_entry
*gotent
;
3646 BFD_ASSERT (h
->dynindx
!= -1);
3648 /* The first .got entry will be updated by the .plt with the
3649 address of the target function. */
3650 gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
3651 BFD_ASSERT (gotent
&& gotent
->addend
== 0);
3653 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3654 BFD_ASSERT (splt
!= NULL
);
3655 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3656 BFD_ASSERT (srel
!= NULL
);
3657 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
3658 BFD_ASSERT (sgot
!= NULL
);
3660 got_addr
= (sgot
->output_section
->vma
3661 + sgot
->output_offset
3662 + gotent
->got_offset
);
3663 plt_addr
= (splt
->output_section
->vma
3664 + splt
->output_offset
3667 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3669 /* Fill in the entry in the procedure linkage table. */
3671 unsigned insn1
, insn2
, insn3
;
3673 insn1
= PLT_ENTRY_WORD1
| ((-(h
->plt
.offset
+ 4) >> 2) & 0x1fffff);
3674 insn2
= PLT_ENTRY_WORD2
;
3675 insn3
= PLT_ENTRY_WORD3
;
3677 bfd_put_32 (output_bfd
, insn1
, splt
->contents
+ h
->plt
.offset
);
3678 bfd_put_32 (output_bfd
, insn2
, splt
->contents
+ h
->plt
.offset
+ 4);
3679 bfd_put_32 (output_bfd
, insn3
, splt
->contents
+ h
->plt
.offset
+ 8);
3682 /* Fill in the entry in the .rela.plt section. */
3683 outrel
.r_offset
= got_addr
;
3684 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
3685 outrel
.r_addend
= 0;
3687 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3688 ((Elf64_External_Rela
*)srel
->contents
3691 if (!(h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3693 /* Mark the symbol as undefined, rather than as defined in the
3694 .plt section. Leave the value alone. */
3695 sym
->st_shndx
= SHN_UNDEF
;
3698 /* Fill in the entries in the .got. */
3699 bfd_put_64 (output_bfd
, plt_addr
, sgot
->contents
+ gotent
->got_offset
);
3701 /* Subsequent .got entries will continue to bounce through the .plt. */
3704 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3705 BFD_ASSERT (! info
->shared
|| srel
!= NULL
);
3707 gotent
= gotent
->next
;
3710 sgot
= alpha_elf_tdata(gotent
->gotobj
)->got
;
3711 BFD_ASSERT(sgot
!= NULL
);
3712 BFD_ASSERT(gotent
->addend
== 0);
3714 bfd_put_64 (output_bfd
, plt_addr
,
3715 sgot
->contents
+ gotent
->got_offset
);
3719 outrel
.r_offset
= (sgot
->output_section
->vma
3720 + sgot
->output_offset
3721 + gotent
->got_offset
);
3722 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
3723 outrel
.r_addend
= plt_addr
;
3725 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3726 ((Elf64_External_Rela
*)
3728 + srel
->reloc_count
++);
3729 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
3730 <= srel
->_cooked_size
);
3733 gotent
= gotent
->next
;
3735 while (gotent
!= NULL
);
3738 else if (alpha_elf_dynamic_symbol_p (h
, info
))
3740 /* Fill in the dynamic relocations for this symbol's .got entries. */
3742 Elf_Internal_Rela outrel
;
3743 struct alpha_elf_got_entry
*gotent
;
3745 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3746 BFD_ASSERT (srel
!= NULL
);
3748 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_ALPHA_GLOB_DAT
);
3749 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
3751 gotent
= gotent
->next
)
3753 asection
*sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
3754 outrel
.r_offset
= (sgot
->output_section
->vma
3755 + sgot
->output_offset
3756 + gotent
->got_offset
);
3757 outrel
.r_addend
= gotent
->addend
;
3759 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3760 ((Elf64_External_Rela
*)srel
->contents
3761 + srel
->reloc_count
++));
3762 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
3763 <= srel
->_cooked_size
);
3767 /* Mark some specially defined symbols as absolute. */
3768 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3769 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3770 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3771 sym
->st_shndx
= SHN_ABS
;
3776 /* Finish up the dynamic sections. */
3779 elf64_alpha_finish_dynamic_sections (output_bfd
, info
)
3781 struct bfd_link_info
*info
;
3786 dynobj
= elf_hash_table (info
)->dynobj
;
3787 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3789 if (elf_hash_table (info
)->dynamic_sections_created
)
3792 Elf64_External_Dyn
*dyncon
, *dynconend
;
3794 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3795 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3797 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3798 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3799 for (; dyncon
< dynconend
; dyncon
++)
3801 Elf_Internal_Dyn dyn
;
3805 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3820 /* My interpretation of the TIS v1.1 ELF document indicates
3821 that RELASZ should not include JMPREL. This is not what
3822 the rest of the BFD does. It is, however, what the
3823 glibc ld.so wants. Do this fixup here until we found
3824 out who is right. */
3825 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
3829 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
3834 s
= bfd_get_section_by_name (output_bfd
, name
);
3835 dyn
.d_un
.d_ptr
= (s
? s
->vma
: 0);
3839 s
= bfd_get_section_by_name (output_bfd
, name
);
3841 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
3845 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3848 /* Initialize the PLT0 entry */
3849 if (splt
->_raw_size
> 0)
3851 bfd_put_32 (output_bfd
, PLT_HEADER_WORD1
, splt
->contents
);
3852 bfd_put_32 (output_bfd
, PLT_HEADER_WORD2
, splt
->contents
+ 4);
3853 bfd_put_32 (output_bfd
, PLT_HEADER_WORD3
, splt
->contents
+ 8);
3854 bfd_put_32 (output_bfd
, PLT_HEADER_WORD4
, splt
->contents
+ 12);
3856 /* The next two words will be filled in by ld.so */
3857 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 16);
3858 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 24);
3860 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
3868 /* We need to use a special link routine to handle the .reginfo and
3869 the .mdebug sections. We need to merge all instances of these
3870 sections together, not write them all out sequentially. */
3873 elf64_alpha_final_link (abfd
, info
)
3875 struct bfd_link_info
*info
;
3878 struct bfd_link_order
*p
;
3879 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
3880 struct ecoff_debug_info debug
;
3881 const struct ecoff_debug_swap
*swap
3882 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3883 HDRR
*symhdr
= &debug
.symbolic_header
;
3884 PTR mdebug_handle
= NULL
;
3889 (*info
->callbacks
->warning
)
3890 (info
, _("using multiple gp values"), (char *) NULL
,
3891 output_bfd
, (asection
*) NULL
, (bfd_vma
) 0);
3895 /* Go through the sections and collect the .reginfo and .mdebug
3899 gptab_data_sec
= NULL
;
3900 gptab_bss_sec
= NULL
;
3901 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
3903 #ifdef ERIC_neverdef
3904 if (strcmp (o
->name
, ".reginfo") == 0)
3906 memset (®info
, 0, sizeof reginfo
);
3908 /* We have found the .reginfo section in the output file.
3909 Look through all the link_orders comprising it and merge
3910 the information together. */
3911 for (p
= o
->link_order_head
;
3912 p
!= (struct bfd_link_order
*) NULL
;
3915 asection
*input_section
;
3917 Elf64_External_RegInfo ext
;
3920 if (p
->type
!= bfd_indirect_link_order
)
3922 if (p
->type
== bfd_fill_link_order
)
3927 input_section
= p
->u
.indirect
.section
;
3928 input_bfd
= input_section
->owner
;
3930 /* The linker emulation code has probably clobbered the
3931 size to be zero bytes. */
3932 if (input_section
->_raw_size
== 0)
3933 input_section
->_raw_size
= sizeof (Elf64_External_RegInfo
);
3935 if (! bfd_get_section_contents (input_bfd
, input_section
,
3941 bfd_alpha_elf64_swap_reginfo_in (input_bfd
, &ext
, &sub
);
3943 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
3944 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
3945 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
3946 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
3947 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
3949 /* ri_gp_value is set by the function
3950 alpha_elf_section_processing when the section is
3951 finally written out. */
3953 /* Hack: reset the SEC_HAS_CONTENTS flag so that
3954 elf_link_input_bfd ignores this section. */
3955 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
3958 /* Force the section size to the value we want. */
3959 o
->_raw_size
= sizeof (Elf64_External_RegInfo
);
3961 /* Skip this section later on (I don't think this currently
3962 matters, but someday it might). */
3963 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
3969 if (strcmp (o
->name
, ".mdebug") == 0)
3971 struct extsym_info einfo
;
3973 /* We have found the .mdebug section in the output file.
3974 Look through all the link_orders comprising it and merge
3975 the information together. */
3976 symhdr
->magic
= swap
->sym_magic
;
3977 /* FIXME: What should the version stamp be? */
3979 symhdr
->ilineMax
= 0;
3983 symhdr
->isymMax
= 0;
3984 symhdr
->ioptMax
= 0;
3985 symhdr
->iauxMax
= 0;
3987 symhdr
->issExtMax
= 0;
3990 symhdr
->iextMax
= 0;
3992 /* We accumulate the debugging information itself in the
3993 debug_info structure. */
3995 debug
.external_dnr
= NULL
;
3996 debug
.external_pdr
= NULL
;
3997 debug
.external_sym
= NULL
;
3998 debug
.external_opt
= NULL
;
3999 debug
.external_aux
= NULL
;
4001 debug
.ssext
= debug
.ssext_end
= NULL
;
4002 debug
.external_fdr
= NULL
;
4003 debug
.external_rfd
= NULL
;
4004 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4006 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4007 if (mdebug_handle
== (PTR
) NULL
)
4016 static const char * const name
[] =
4018 ".text", ".init", ".fini", ".data",
4019 ".rodata", ".sdata", ".sbss", ".bss"
4021 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
4022 scRData
, scSData
, scSBss
, scBss
};
4025 esym
.cobol_main
= 0;
4029 esym
.asym
.iss
= issNil
;
4030 esym
.asym
.st
= stLocal
;
4031 esym
.asym
.reserved
= 0;
4032 esym
.asym
.index
= indexNil
;
4033 for (i
= 0; i
< 8; i
++)
4035 esym
.asym
.sc
= sc
[i
];
4036 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4039 esym
.asym
.value
= s
->vma
;
4040 last
= s
->vma
+ s
->_raw_size
;
4043 esym
.asym
.value
= last
;
4045 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4051 for (p
= o
->link_order_head
;
4052 p
!= (struct bfd_link_order
*) NULL
;
4055 asection
*input_section
;
4057 const struct ecoff_debug_swap
*input_swap
;
4058 struct ecoff_debug_info input_debug
;
4062 if (p
->type
!= bfd_indirect_link_order
)
4064 if (p
->type
== bfd_fill_link_order
)
4069 input_section
= p
->u
.indirect
.section
;
4070 input_bfd
= input_section
->owner
;
4072 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4073 || (get_elf_backend_data (input_bfd
)
4074 ->elf_backend_ecoff_debug_swap
) == NULL
)
4076 /* I don't know what a non ALPHA ELF bfd would be
4077 doing with a .mdebug section, but I don't really
4078 want to deal with it. */
4082 input_swap
= (get_elf_backend_data (input_bfd
)
4083 ->elf_backend_ecoff_debug_swap
);
4085 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4087 /* The ECOFF linking code expects that we have already
4088 read in the debugging information and set up an
4089 ecoff_debug_info structure, so we do that now. */
4090 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
4094 if (! (bfd_ecoff_debug_accumulate
4095 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4096 &input_debug
, input_swap
, info
)))
4099 /* Loop through the external symbols. For each one with
4100 interesting information, try to find the symbol in
4101 the linker global hash table and save the information
4102 for the output external symbols. */
4103 eraw_src
= input_debug
.external_ext
;
4104 eraw_end
= (eraw_src
4105 + (input_debug
.symbolic_header
.iextMax
4106 * input_swap
->external_ext_size
));
4108 eraw_src
< eraw_end
;
4109 eraw_src
+= input_swap
->external_ext_size
)
4113 struct alpha_elf_link_hash_entry
*h
;
4115 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4116 if (ext
.asym
.sc
== scNil
4117 || ext
.asym
.sc
== scUndefined
4118 || ext
.asym
.sc
== scSUndefined
)
4121 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4122 h
= alpha_elf_link_hash_lookup (alpha_elf_hash_table (info
),
4123 name
, false, false, true);
4124 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4130 < input_debug
.symbolic_header
.ifdMax
);
4131 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4137 /* Free up the information we just read. */
4138 free (input_debug
.line
);
4139 free (input_debug
.external_dnr
);
4140 free (input_debug
.external_pdr
);
4141 free (input_debug
.external_sym
);
4142 free (input_debug
.external_opt
);
4143 free (input_debug
.external_aux
);
4144 free (input_debug
.ss
);
4145 free (input_debug
.ssext
);
4146 free (input_debug
.external_fdr
);
4147 free (input_debug
.external_rfd
);
4148 free (input_debug
.external_ext
);
4150 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4151 elf_link_input_bfd ignores this section. */
4152 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4155 #ifdef ERIC_neverdef
4158 /* Create .rtproc section. */
4159 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4160 if (rtproc_sec
== NULL
)
4162 flagword flags
= (SEC_HAS_CONTENTS
4164 | SEC_LINKER_CREATED
4167 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4168 if (rtproc_sec
== NULL
4169 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4170 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 12))
4174 if (! alpha_elf_create_procedure_table (mdebug_handle
, abfd
,
4175 info
, rtproc_sec
, &debug
))
4180 /* Build the external symbol information. */
4183 einfo
.debug
= &debug
;
4185 einfo
.failed
= false;
4186 elf_link_hash_traverse (elf_hash_table (info
),
4187 elf64_alpha_output_extsym
,
4192 /* Set the size of the .mdebug section. */
4193 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4195 /* Skip this section later on (I don't think this currently
4196 matters, but someday it might). */
4197 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4202 #ifdef ERIC_neverdef
4203 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4205 const char *subname
;
4208 Elf64_External_gptab
*ext_tab
;
4211 /* The .gptab.sdata and .gptab.sbss sections hold
4212 information describing how the small data area would
4213 change depending upon the -G switch. These sections
4214 not used in executables files. */
4215 if (! info
->relocateable
)
4219 for (p
= o
->link_order_head
;
4220 p
!= (struct bfd_link_order
*) NULL
;
4223 asection
*input_section
;
4225 if (p
->type
!= bfd_indirect_link_order
)
4227 if (p
->type
== bfd_fill_link_order
)
4232 input_section
= p
->u
.indirect
.section
;
4234 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4235 elf_link_input_bfd ignores this section. */
4236 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4239 /* Skip this section later on (I don't think this
4240 currently matters, but someday it might). */
4241 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4243 /* Really remove the section. */
4244 for (secpp
= &abfd
->sections
;
4246 secpp
= &(*secpp
)->next
)
4248 *secpp
= (*secpp
)->next
;
4249 --abfd
->section_count
;
4254 /* There is one gptab for initialized data, and one for
4255 uninitialized data. */
4256 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4258 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4262 (*_bfd_error_handler
)
4263 (_("%s: illegal section name `%s'"),
4264 bfd_get_filename (abfd
), o
->name
);
4265 bfd_set_error (bfd_error_nonrepresentable_section
);
4269 /* The linker script always combines .gptab.data and
4270 .gptab.sdata into .gptab.sdata, and likewise for
4271 .gptab.bss and .gptab.sbss. It is possible that there is
4272 no .sdata or .sbss section in the output file, in which
4273 case we must change the name of the output section. */
4274 subname
= o
->name
+ sizeof ".gptab" - 1;
4275 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4277 if (o
== gptab_data_sec
)
4278 o
->name
= ".gptab.data";
4280 o
->name
= ".gptab.bss";
4281 subname
= o
->name
+ sizeof ".gptab" - 1;
4282 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4285 /* Set up the first entry. */
4287 tab
= (Elf64_gptab
*) bfd_malloc (c
* sizeof (Elf64_gptab
));
4290 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4291 tab
[0].gt_header
.gt_unused
= 0;
4293 /* Combine the input sections. */
4294 for (p
= o
->link_order_head
;
4295 p
!= (struct bfd_link_order
*) NULL
;
4298 asection
*input_section
;
4302 bfd_size_type gpentry
;
4304 if (p
->type
!= bfd_indirect_link_order
)
4306 if (p
->type
== bfd_fill_link_order
)
4311 input_section
= p
->u
.indirect
.section
;
4312 input_bfd
= input_section
->owner
;
4314 /* Combine the gptab entries for this input section one
4315 by one. We know that the input gptab entries are
4316 sorted by ascending -G value. */
4317 size
= bfd_section_size (input_bfd
, input_section
);
4319 for (gpentry
= sizeof (Elf64_External_gptab
);
4321 gpentry
+= sizeof (Elf64_External_gptab
))
4323 Elf64_External_gptab ext_gptab
;
4324 Elf64_gptab int_gptab
;
4330 if (! (bfd_get_section_contents
4331 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
4332 gpentry
, sizeof (Elf64_External_gptab
))))
4338 bfd_alpha_elf64_swap_gptab_in (input_bfd
, &ext_gptab
,
4340 val
= int_gptab
.gt_entry
.gt_g_value
;
4341 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
4344 for (look
= 1; look
< c
; look
++)
4346 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
4347 tab
[look
].gt_entry
.gt_bytes
+= add
;
4349 if (tab
[look
].gt_entry
.gt_g_value
== val
)
4355 Elf64_gptab
*new_tab
;
4358 /* We need a new table entry. */
4359 new_tab
= ((Elf64_gptab
*)
4360 bfd_realloc ((PTR
) tab
,
4361 (c
+ 1) * sizeof (Elf64_gptab
)));
4362 if (new_tab
== NULL
)
4368 tab
[c
].gt_entry
.gt_g_value
= val
;
4369 tab
[c
].gt_entry
.gt_bytes
= add
;
4371 /* Merge in the size for the next smallest -G
4372 value, since that will be implied by this new
4375 for (look
= 1; look
< c
; look
++)
4377 if (tab
[look
].gt_entry
.gt_g_value
< val
4379 || (tab
[look
].gt_entry
.gt_g_value
4380 > tab
[max
].gt_entry
.gt_g_value
)))
4384 tab
[c
].gt_entry
.gt_bytes
+=
4385 tab
[max
].gt_entry
.gt_bytes
;
4390 last
= int_gptab
.gt_entry
.gt_bytes
;
4393 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4394 elf_link_input_bfd ignores this section. */
4395 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4398 /* The table must be sorted by -G value. */
4400 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
4402 /* Swap out the table. */
4403 ext_tab
= ((Elf64_External_gptab
*)
4404 bfd_alloc (abfd
, c
* sizeof (Elf64_External_gptab
)));
4405 if (ext_tab
== NULL
)
4411 for (i
= 0; i
< c
; i
++)
4412 bfd_alpha_elf64_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
4415 o
->_raw_size
= c
* sizeof (Elf64_External_gptab
);
4416 o
->contents
= (bfd_byte
*) ext_tab
;
4418 /* Skip this section later on (I don't think this currently
4419 matters, but someday it might). */
4420 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4426 /* Invoke the regular ELF backend linker to do all the work. */
4427 if (! bfd_elf64_bfd_final_link (abfd
, info
))
4430 /* Now write out the computed sections. */
4432 /* The .got subsections... */
4434 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
4435 for (i
= alpha_elf_hash_table(info
)->got_list
;
4437 i
= alpha_elf_tdata(i
)->got_link_next
)
4441 /* elf_bfd_final_link already did everything in dynobj. */
4445 sgot
= alpha_elf_tdata(i
)->got
;
4446 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
4447 sgot
->contents
, sgot
->output_offset
,
4453 #ifdef ERIC_neverdef
4454 if (reginfo_sec
!= (asection
*) NULL
)
4456 Elf64_External_RegInfo ext
;
4458 bfd_alpha_elf64_swap_reginfo_out (abfd
, ®info
, &ext
);
4459 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
4460 (file_ptr
) 0, sizeof ext
))
4465 if (mdebug_sec
!= (asection
*) NULL
)
4467 BFD_ASSERT (abfd
->output_has_begun
);
4468 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
4470 mdebug_sec
->filepos
))
4473 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
4476 if (gptab_data_sec
!= (asection
*) NULL
)
4478 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
4479 gptab_data_sec
->contents
,
4481 gptab_data_sec
->_raw_size
))
4485 if (gptab_bss_sec
!= (asection
*) NULL
)
4487 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
4488 gptab_bss_sec
->contents
,
4490 gptab_bss_sec
->_raw_size
))
4497 static enum elf_reloc_type_class
4498 elf64_alpha_reloc_type_class (type
)
4503 case R_ALPHA_RELATIVE
:
4504 return reloc_class_relative
;
4505 case R_ALPHA_JMP_SLOT
:
4506 return reloc_class_plt
;
4508 return reloc_class_copy
;
4510 return reloc_class_normal
;
4514 /* ECOFF swapping routines. These are used when dealing with the
4515 .mdebug section, which is in the ECOFF debugging format. Copied
4516 from elf32-mips.c. */
4517 static const struct ecoff_debug_swap
4518 elf64_alpha_ecoff_debug_swap
=
4520 /* Symbol table magic number. */
4522 /* Alignment of debugging information. E.g., 4. */
4524 /* Sizes of external symbolic information. */
4525 sizeof (struct hdr_ext
),
4526 sizeof (struct dnr_ext
),
4527 sizeof (struct pdr_ext
),
4528 sizeof (struct sym_ext
),
4529 sizeof (struct opt_ext
),
4530 sizeof (struct fdr_ext
),
4531 sizeof (struct rfd_ext
),
4532 sizeof (struct ext_ext
),
4533 /* Functions to swap in external symbolic data. */
4542 _bfd_ecoff_swap_tir_in
,
4543 _bfd_ecoff_swap_rndx_in
,
4544 /* Functions to swap out external symbolic data. */
4553 _bfd_ecoff_swap_tir_out
,
4554 _bfd_ecoff_swap_rndx_out
,
4555 /* Function to read in symbolic data. */
4556 elf64_alpha_read_ecoff_info
4559 /* Use a non-standard hash bucket size of 8. */
4561 const struct elf_size_info alpha_elf_size_info
=
4563 sizeof (Elf64_External_Ehdr
),
4564 sizeof (Elf64_External_Phdr
),
4565 sizeof (Elf64_External_Shdr
),
4566 sizeof (Elf64_External_Rel
),
4567 sizeof (Elf64_External_Rela
),
4568 sizeof (Elf64_External_Sym
),
4569 sizeof (Elf64_External_Dyn
),
4570 sizeof (Elf_External_Note
),
4574 ELFCLASS64
, EV_CURRENT
,
4575 bfd_elf64_write_out_phdrs
,
4576 bfd_elf64_write_shdrs_and_ehdr
,
4577 bfd_elf64_write_relocs
,
4578 bfd_elf64_swap_symbol_out
,
4579 bfd_elf64_slurp_reloc_table
,
4580 bfd_elf64_slurp_symbol_table
,
4581 bfd_elf64_swap_dyn_in
,
4582 bfd_elf64_swap_dyn_out
,
4589 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4590 #define TARGET_LITTLE_NAME "elf64-alpha"
4591 #define ELF_ARCH bfd_arch_alpha
4592 #define ELF_MACHINE_CODE EM_ALPHA
4593 #define ELF_MAXPAGESIZE 0x10000
4595 #define bfd_elf64_bfd_link_hash_table_create \
4596 elf64_alpha_bfd_link_hash_table_create
4598 #define bfd_elf64_bfd_reloc_type_lookup \
4599 elf64_alpha_bfd_reloc_type_lookup
4600 #define elf_info_to_howto \
4601 elf64_alpha_info_to_howto
4603 #define bfd_elf64_mkobject \
4604 elf64_alpha_mkobject
4605 #define elf_backend_object_p \
4606 elf64_alpha_object_p
4608 #define elf_backend_section_from_shdr \
4609 elf64_alpha_section_from_shdr
4610 #define elf_backend_fake_sections \
4611 elf64_alpha_fake_sections
4613 #define bfd_elf64_bfd_is_local_label_name \
4614 elf64_alpha_is_local_label_name
4615 #define bfd_elf64_find_nearest_line \
4616 elf64_alpha_find_nearest_line
4617 #define bfd_elf64_bfd_relax_section \
4618 elf64_alpha_relax_section
4620 #define elf_backend_add_symbol_hook \
4621 elf64_alpha_add_symbol_hook
4622 #define elf_backend_check_relocs \
4623 elf64_alpha_check_relocs
4624 #define elf_backend_create_dynamic_sections \
4625 elf64_alpha_create_dynamic_sections
4626 #define elf_backend_adjust_dynamic_symbol \
4627 elf64_alpha_adjust_dynamic_symbol
4628 #define elf_backend_always_size_sections \
4629 elf64_alpha_always_size_sections
4630 #define elf_backend_size_dynamic_sections \
4631 elf64_alpha_size_dynamic_sections
4632 #define elf_backend_relocate_section \
4633 elf64_alpha_relocate_section
4634 #define elf_backend_finish_dynamic_symbol \
4635 elf64_alpha_finish_dynamic_symbol
4636 #define elf_backend_finish_dynamic_sections \
4637 elf64_alpha_finish_dynamic_sections
4638 #define bfd_elf64_bfd_final_link \
4639 elf64_alpha_final_link
4640 #define elf_backend_reloc_type_class \
4641 elf64_alpha_reloc_type_class
4643 #define elf_backend_ecoff_debug_swap \
4644 &elf64_alpha_ecoff_debug_swap
4646 #define elf_backend_size_info \
4649 /* A few constants that determine how the .plt section is set up. */
4650 #define elf_backend_want_got_plt 0
4651 #define elf_backend_plt_readonly 0
4652 #define elf_backend_want_plt_sym 1
4653 #define elf_backend_got_header_size 0
4654 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4656 #include "elf64-target.h"