1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
4 Contributed by Richard Henderson <rth@tamu.edu>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* We need a published ABI spec for this. Until one comes out, don't
23 assume this'll remain unchanged forever. */
30 #include "elf/alpha.h"
34 #define NO_COFF_RELOCS
35 #define NO_COFF_SYMBOLS
36 #define NO_COFF_LINENOS
38 /* Get the ECOFF swapping routines. Needed for the debug information. */
39 #include "coff/internal.h"
41 #include "coff/symconst.h"
42 #include "coff/ecoff.h"
43 #include "coff/alpha.h"
48 #include "ecoffswap.h"
50 static int alpha_elf_dynamic_symbol_p
51 PARAMS((struct elf_link_hash_entry
*, struct bfd_link_info
*));
52 static struct bfd_hash_entry
* elf64_alpha_link_hash_newfunc
53 PARAMS((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
54 static struct bfd_link_hash_table
* elf64_alpha_bfd_link_hash_table_create
57 static bfd_reloc_status_type elf64_alpha_reloc_nil
58 PARAMS((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
59 static bfd_reloc_status_type elf64_alpha_reloc_bad
60 PARAMS((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
61 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
62 PARAMS((bfd
*, bfd_vma
, bfd_byte
*, bfd_byte
*));
63 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
64 PARAMS((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
66 static reloc_howto_type
* elf64_alpha_bfd_reloc_type_lookup
67 PARAMS((bfd
*, bfd_reloc_code_real_type
));
68 static void elf64_alpha_info_to_howto
69 PARAMS((bfd
*, arelent
*, Elf64_Internal_Rela
*));
71 static boolean elf64_alpha_mkobject
73 static boolean elf64_alpha_object_p
75 static boolean elf64_alpha_section_from_shdr
76 PARAMS((bfd
*, Elf64_Internal_Shdr
*, char *));
77 static boolean elf64_alpha_section_flags
78 PARAMS((flagword
*, Elf64_Internal_Shdr
*));
79 static boolean elf64_alpha_fake_sections
80 PARAMS((bfd
*, Elf64_Internal_Shdr
*, asection
*));
81 static boolean elf64_alpha_create_got_section
82 PARAMS((bfd
*, struct bfd_link_info
*));
83 static boolean elf64_alpha_create_dynamic_sections
84 PARAMS((bfd
*, struct bfd_link_info
*));
86 static boolean elf64_alpha_read_ecoff_info
87 PARAMS((bfd
*, asection
*, struct ecoff_debug_info
*));
88 static boolean elf64_alpha_is_local_label_name
89 PARAMS((bfd
*, const char *));
90 static boolean elf64_alpha_find_nearest_line
91 PARAMS((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
92 const char **, unsigned int *));
94 #if defined(__STDC__) || defined(ALMOST_STDC)
95 struct alpha_elf_link_hash_entry
;
98 static boolean elf64_alpha_output_extsym
99 PARAMS((struct alpha_elf_link_hash_entry
*, PTR
));
101 static boolean elf64_alpha_can_merge_gots
102 PARAMS((bfd
*, bfd
*));
103 static void elf64_alpha_merge_gots
104 PARAMS((bfd
*, bfd
*));
105 static boolean elf64_alpha_calc_got_offsets_for_symbol
106 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
107 static void elf64_alpha_calc_got_offsets
PARAMS ((struct bfd_link_info
*));
108 static boolean elf64_alpha_size_got_sections
109 PARAMS ((bfd
*, struct bfd_link_info
*));
110 static boolean elf64_alpha_always_size_sections
111 PARAMS ((bfd
*, struct bfd_link_info
*));
112 static int alpha_dynamic_entries_for_reloc
113 PARAMS ((int, int, int));
114 static boolean elf64_alpha_calc_dynrel_sizes
115 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
116 static boolean elf64_alpha_add_symbol_hook
117 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
118 const char **, flagword
*, asection
**, bfd_vma
*));
119 static struct alpha_elf_got_entry
*get_got_entry
120 PARAMS ((bfd
*, struct alpha_elf_link_hash_entry
*, unsigned long,
121 unsigned long, bfd_vma
));
122 static boolean elf64_alpha_check_relocs
123 PARAMS((bfd
*, struct bfd_link_info
*, asection
*sec
,
124 const Elf_Internal_Rela
*));
125 static boolean elf64_alpha_adjust_dynamic_symbol
126 PARAMS((struct bfd_link_info
*, struct elf_link_hash_entry
*));
127 static boolean elf64_alpha_size_dynamic_sections
128 PARAMS((bfd
*, struct bfd_link_info
*));
129 static boolean elf64_alpha_relocate_section
130 PARAMS((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
131 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
132 static boolean elf64_alpha_finish_dynamic_symbol
133 PARAMS((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
134 Elf_Internal_Sym
*));
135 static boolean elf64_alpha_finish_dynamic_sections
136 PARAMS((bfd
*, struct bfd_link_info
*));
137 static boolean elf64_alpha_final_link
138 PARAMS((bfd
*, struct bfd_link_info
*));
139 static boolean elf64_alpha_merge_ind_symbols
140 PARAMS((struct alpha_elf_link_hash_entry
*, PTR
));
141 static Elf_Internal_Rela
* elf64_alpha_find_reloc_at_ofs
142 PARAMS ((Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_vma
, int));
143 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
144 PARAMS ((const Elf_Internal_Rela
*));
146 struct alpha_elf_link_hash_entry
148 struct elf_link_hash_entry root
;
150 /* External symbol information. */
153 /* Cumulative flags for all the .got entries. */
156 /* Contexts (LITUSE) in which a literal was referenced. */
157 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
158 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
159 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
160 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
161 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
162 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
163 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x38
165 /* Used to implement multiple .got subsections. */
166 struct alpha_elf_got_entry
168 struct alpha_elf_got_entry
*next
;
170 /* which .got subsection? */
173 /* the addend in effect for this entry. */
176 /* the .got offset for this entry. */
179 /* How many references to this entry? */
182 /* The relocation type of this entry. */
183 unsigned char reloc_type
;
185 /* How a LITERAL is used. */
188 /* Have we initialized the dynamic relocation for this entry? */
189 unsigned char reloc_done
;
191 /* Have we adjusted this entry for SEC_MERGE? */
192 unsigned char reloc_xlated
;
195 /* used to count non-got, non-plt relocations for delayed sizing
196 of relocation sections. */
197 struct alpha_elf_reloc_entry
199 struct alpha_elf_reloc_entry
*next
;
201 /* which .reloc section? */
204 /* what kind of relocation? */
207 /* is this against read-only section? */
208 unsigned int reltext
: 1;
210 /* how many did we find? */
215 /* Alpha ELF linker hash table. */
217 struct alpha_elf_link_hash_table
219 struct elf_link_hash_table root
;
221 /* The head of a list of .got subsections linked through
222 alpha_elf_tdata(abfd)->got_link_next. */
226 /* Look up an entry in a Alpha ELF linker hash table. */
228 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
229 ((struct alpha_elf_link_hash_entry *) \
230 elf_link_hash_lookup (&(table)->root, (string), (create), \
233 /* Traverse a Alpha ELF linker hash table. */
235 #define alpha_elf_link_hash_traverse(table, func, info) \
236 (elf_link_hash_traverse \
238 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
241 /* Get the Alpha ELF linker hash table from a link_info structure. */
243 #define alpha_elf_hash_table(p) \
244 ((struct alpha_elf_link_hash_table *) ((p)->hash))
246 /* Get the object's symbols as our own entry type. */
248 #define alpha_elf_sym_hashes(abfd) \
249 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
251 /* Should we do dynamic things to this symbol? */
254 alpha_elf_dynamic_symbol_p (h
, info
)
255 struct elf_link_hash_entry
*h
;
256 struct bfd_link_info
*info
;
261 while (h
->root
.type
== bfd_link_hash_indirect
262 || h
->root
.type
== bfd_link_hash_warning
)
263 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
265 if (h
->dynindx
== -1)
268 if (h
->root
.type
== bfd_link_hash_undefweak
269 || h
->root
.type
== bfd_link_hash_defweak
)
272 switch (ELF_ST_VISIBILITY (h
->other
))
280 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
285 if ((info
->shared
&& !info
->symbolic
)
286 || ((h
->elf_link_hash_flags
287 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
288 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
294 /* Create an entry in a Alpha ELF linker hash table. */
296 static struct bfd_hash_entry
*
297 elf64_alpha_link_hash_newfunc (entry
, table
, string
)
298 struct bfd_hash_entry
*entry
;
299 struct bfd_hash_table
*table
;
302 struct alpha_elf_link_hash_entry
*ret
=
303 (struct alpha_elf_link_hash_entry
*) entry
;
305 /* Allocate the structure if it has not already been allocated by a
307 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
308 ret
= ((struct alpha_elf_link_hash_entry
*)
309 bfd_hash_allocate (table
,
310 sizeof (struct alpha_elf_link_hash_entry
)));
311 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
312 return (struct bfd_hash_entry
*) ret
;
314 /* Call the allocation method of the superclass. */
315 ret
= ((struct alpha_elf_link_hash_entry
*)
316 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
318 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
320 /* Set local fields. */
321 memset (&ret
->esym
, 0, sizeof (EXTR
));
322 /* We use -2 as a marker to indicate that the information has
323 not been set. -1 means there is no associated ifd. */
326 ret
->got_entries
= NULL
;
327 ret
->reloc_entries
= NULL
;
330 return (struct bfd_hash_entry
*) ret
;
333 /* Create a Alpha ELF linker hash table. */
335 static struct bfd_link_hash_table
*
336 elf64_alpha_bfd_link_hash_table_create (abfd
)
339 struct alpha_elf_link_hash_table
*ret
;
340 bfd_size_type amt
= sizeof (struct alpha_elf_link_hash_table
);
342 ret
= (struct alpha_elf_link_hash_table
*) bfd_zmalloc (amt
);
343 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
346 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
347 elf64_alpha_link_hash_newfunc
))
353 return &ret
->root
.root
;
356 /* We have some private fields hanging off of the elf_tdata structure. */
358 struct alpha_elf_obj_tdata
360 struct elf_obj_tdata root
;
362 /* For every input file, these are the got entries for that object's
364 struct alpha_elf_got_entry
** local_got_entries
;
366 /* For every input file, this is the object that owns the got that
367 this input file uses. */
370 /* For every got, this is a linked list through the objects using this got */
371 bfd
*in_got_link_next
;
373 /* For every got, this is a link to the next got subsegment. */
376 /* For every got, this is the section. */
379 /* For every got, this is it's total number of words. */
382 /* For every got, this is the sum of the number of words required
383 to hold all of the member object's local got. */
387 #define alpha_elf_tdata(abfd) \
388 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
391 elf64_alpha_mkobject (abfd
)
394 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
395 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
396 if (abfd
->tdata
.any
== NULL
)
402 elf64_alpha_object_p (abfd
)
405 /* Allocate our special target data. */
406 struct alpha_elf_obj_tdata
*new_tdata
;
407 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
408 new_tdata
= bfd_zalloc (abfd
, amt
);
409 if (new_tdata
== NULL
)
411 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
412 abfd
->tdata
.any
= new_tdata
;
414 /* Set the right machine number for an Alpha ELF file. */
415 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
418 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
419 from smaller values. Start with zero, widen, *then* decrement. */
420 #define MINUS_ONE (((bfd_vma)0) - 1)
422 #define SKIP_HOWTO(N) \
423 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
425 static reloc_howto_type elf64_alpha_howto_table
[] =
427 HOWTO (R_ALPHA_NONE
, /* type */
429 0, /* size (0 = byte, 1 = short, 2 = long) */
431 true, /* pc_relative */
433 complain_overflow_dont
, /* complain_on_overflow */
434 elf64_alpha_reloc_nil
, /* special_function */
436 false, /* partial_inplace */
439 true), /* pcrel_offset */
441 /* A 32 bit reference to a symbol. */
442 HOWTO (R_ALPHA_REFLONG
, /* type */
444 2, /* size (0 = byte, 1 = short, 2 = long) */
446 false, /* pc_relative */
448 complain_overflow_bitfield
, /* complain_on_overflow */
449 0, /* special_function */
450 "REFLONG", /* name */
451 false, /* partial_inplace */
452 0xffffffff, /* src_mask */
453 0xffffffff, /* dst_mask */
454 false), /* pcrel_offset */
456 /* A 64 bit reference to a symbol. */
457 HOWTO (R_ALPHA_REFQUAD
, /* type */
459 4, /* size (0 = byte, 1 = short, 2 = long) */
461 false, /* pc_relative */
463 complain_overflow_bitfield
, /* complain_on_overflow */
464 0, /* special_function */
465 "REFQUAD", /* name */
466 false, /* partial_inplace */
467 MINUS_ONE
, /* src_mask */
468 MINUS_ONE
, /* dst_mask */
469 false), /* pcrel_offset */
471 /* A 32 bit GP relative offset. This is just like REFLONG except
472 that when the value is used the value of the gp register will be
474 HOWTO (R_ALPHA_GPREL32
, /* type */
476 2, /* size (0 = byte, 1 = short, 2 = long) */
478 false, /* pc_relative */
480 complain_overflow_bitfield
, /* complain_on_overflow */
481 0, /* special_function */
482 "GPREL32", /* name */
483 false, /* partial_inplace */
484 0xffffffff, /* src_mask */
485 0xffffffff, /* dst_mask */
486 false), /* pcrel_offset */
488 /* Used for an instruction that refers to memory off the GP register. */
489 HOWTO (R_ALPHA_LITERAL
, /* type */
491 1, /* size (0 = byte, 1 = short, 2 = long) */
493 false, /* pc_relative */
495 complain_overflow_signed
, /* complain_on_overflow */
496 0, /* special_function */
497 "ELF_LITERAL", /* name */
498 false, /* partial_inplace */
499 0xffff, /* src_mask */
500 0xffff, /* dst_mask */
501 false), /* pcrel_offset */
503 /* This reloc only appears immediately following an ELF_LITERAL reloc.
504 It identifies a use of the literal. The symbol index is special:
505 1 means the literal address is in the base register of a memory
506 format instruction; 2 means the literal address is in the byte
507 offset register of a byte-manipulation instruction; 3 means the
508 literal address is in the target register of a jsr instruction.
509 This does not actually do any relocation. */
510 HOWTO (R_ALPHA_LITUSE
, /* type */
512 1, /* size (0 = byte, 1 = short, 2 = long) */
514 false, /* pc_relative */
516 complain_overflow_dont
, /* complain_on_overflow */
517 elf64_alpha_reloc_nil
, /* special_function */
519 false, /* partial_inplace */
522 false), /* pcrel_offset */
524 /* Load the gp register. This is always used for a ldah instruction
525 which loads the upper 16 bits of the gp register. The symbol
526 index of the GPDISP instruction is an offset in bytes to the lda
527 instruction that loads the lower 16 bits. The value to use for
528 the relocation is the difference between the GP value and the
529 current location; the load will always be done against a register
530 holding the current address.
532 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
533 any offset is present in the instructions, it is an offset from
534 the register to the ldah instruction. This lets us avoid any
535 stupid hackery like inventing a gp value to do partial relocation
536 against. Also unlike ECOFF, we do the whole relocation off of
537 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
538 space consuming bit, that, since all the information was present
539 in the GPDISP_HI16 reloc. */
540 HOWTO (R_ALPHA_GPDISP
, /* type */
542 2, /* size (0 = byte, 1 = short, 2 = long) */
544 false, /* pc_relative */
546 complain_overflow_dont
, /* complain_on_overflow */
547 elf64_alpha_reloc_gpdisp
, /* special_function */
549 false, /* partial_inplace */
550 0xffff, /* src_mask */
551 0xffff, /* dst_mask */
552 true), /* pcrel_offset */
554 /* A 21 bit branch. */
555 HOWTO (R_ALPHA_BRADDR
, /* type */
557 2, /* size (0 = byte, 1 = short, 2 = long) */
559 true, /* pc_relative */
561 complain_overflow_signed
, /* complain_on_overflow */
562 0, /* special_function */
564 false, /* partial_inplace */
565 0x1fffff, /* src_mask */
566 0x1fffff, /* dst_mask */
567 true), /* pcrel_offset */
569 /* A hint for a jump to a register. */
570 HOWTO (R_ALPHA_HINT
, /* type */
572 1, /* size (0 = byte, 1 = short, 2 = long) */
574 true, /* pc_relative */
576 complain_overflow_dont
, /* complain_on_overflow */
577 0, /* special_function */
579 false, /* partial_inplace */
580 0x3fff, /* src_mask */
581 0x3fff, /* dst_mask */
582 true), /* pcrel_offset */
584 /* 16 bit PC relative offset. */
585 HOWTO (R_ALPHA_SREL16
, /* type */
587 1, /* size (0 = byte, 1 = short, 2 = long) */
589 true, /* pc_relative */
591 complain_overflow_signed
, /* complain_on_overflow */
592 0, /* special_function */
594 false, /* partial_inplace */
595 0xffff, /* src_mask */
596 0xffff, /* dst_mask */
597 true), /* pcrel_offset */
599 /* 32 bit PC relative offset. */
600 HOWTO (R_ALPHA_SREL32
, /* type */
602 2, /* size (0 = byte, 1 = short, 2 = long) */
604 true, /* pc_relative */
606 complain_overflow_signed
, /* complain_on_overflow */
607 0, /* special_function */
609 false, /* partial_inplace */
610 0xffffffff, /* src_mask */
611 0xffffffff, /* dst_mask */
612 true), /* pcrel_offset */
614 /* A 64 bit PC relative offset. */
615 HOWTO (R_ALPHA_SREL64
, /* type */
617 4, /* size (0 = byte, 1 = short, 2 = long) */
619 true, /* pc_relative */
621 complain_overflow_signed
, /* complain_on_overflow */
622 0, /* special_function */
624 false, /* partial_inplace */
625 MINUS_ONE
, /* src_mask */
626 MINUS_ONE
, /* dst_mask */
627 true), /* pcrel_offset */
629 /* Skip 12 - 16; deprecated ECOFF relocs. */
636 /* The high 16 bits of the displacement from GP to the target. */
637 HOWTO (R_ALPHA_GPRELHIGH
,
639 1, /* size (0 = byte, 1 = short, 2 = long) */
641 false, /* pc_relative */
643 complain_overflow_signed
, /* complain_on_overflow */
644 0, /* special_function */
645 "GPRELHIGH", /* name */
646 false, /* partial_inplace */
647 0xffff, /* src_mask */
648 0xffff, /* dst_mask */
649 false), /* pcrel_offset */
651 /* The low 16 bits of the displacement from GP to the target. */
652 HOWTO (R_ALPHA_GPRELLOW
,
654 1, /* size (0 = byte, 1 = short, 2 = long) */
656 false, /* pc_relative */
658 complain_overflow_dont
, /* complain_on_overflow */
659 0, /* special_function */
660 "GPRELLOW", /* name */
661 false, /* partial_inplace */
662 0xffff, /* src_mask */
663 0xffff, /* dst_mask */
664 false), /* pcrel_offset */
666 /* A 16-bit displacement from the GP to the target. */
667 HOWTO (R_ALPHA_GPREL16
,
669 1, /* size (0 = byte, 1 = short, 2 = long) */
671 false, /* pc_relative */
673 complain_overflow_signed
, /* complain_on_overflow */
674 0, /* special_function */
675 "GPREL16", /* name */
676 false, /* partial_inplace */
677 0xffff, /* src_mask */
678 0xffff, /* dst_mask */
679 false), /* pcrel_offset */
681 /* Skip 20 - 23; deprecated ECOFF relocs. */
687 /* Misc ELF relocations. */
689 /* A dynamic relocation to copy the target into our .dynbss section. */
690 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
691 is present because every other ELF has one, but should not be used
692 because .dynbss is an ugly thing. */
699 complain_overflow_dont
,
700 bfd_elf_generic_reloc
,
707 /* A dynamic relocation for a .got entry. */
708 HOWTO (R_ALPHA_GLOB_DAT
,
714 complain_overflow_dont
,
715 bfd_elf_generic_reloc
,
722 /* A dynamic relocation for a .plt entry. */
723 HOWTO (R_ALPHA_JMP_SLOT
,
729 complain_overflow_dont
,
730 bfd_elf_generic_reloc
,
737 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
738 HOWTO (R_ALPHA_RELATIVE
,
744 complain_overflow_dont
,
745 bfd_elf_generic_reloc
,
752 /* A 21 bit branch that adjusts for gp loads. */
753 HOWTO (R_ALPHA_BRSGP
, /* type */
755 2, /* size (0 = byte, 1 = short, 2 = long) */
757 true, /* pc_relative */
759 complain_overflow_signed
, /* complain_on_overflow */
760 0, /* special_function */
762 false, /* partial_inplace */
763 0x1fffff, /* src_mask */
764 0x1fffff, /* dst_mask */
765 true), /* pcrel_offset */
767 /* Creates a tls_index for the symbol in the got. */
768 HOWTO (R_ALPHA_TLSGD
, /* type */
770 1, /* size (0 = byte, 1 = short, 2 = long) */
772 false, /* pc_relative */
774 complain_overflow_signed
, /* complain_on_overflow */
775 0, /* special_function */
777 false, /* partial_inplace */
778 0xffff, /* src_mask */
779 0xffff, /* dst_mask */
780 false), /* pcrel_offset */
782 /* Creates a tls_index for the (current) module in the got. */
783 HOWTO (R_ALPHA_TLSLDM
, /* type */
785 1, /* size (0 = byte, 1 = short, 2 = long) */
787 false, /* pc_relative */
789 complain_overflow_signed
, /* complain_on_overflow */
790 0, /* special_function */
792 false, /* partial_inplace */
793 0xffff, /* src_mask */
794 0xffff, /* dst_mask */
795 false), /* pcrel_offset */
797 /* A dynamic relocation for a DTP module entry. */
798 HOWTO (R_ALPHA_DTPMOD64
, /* type */
800 4, /* size (0 = byte, 1 = short, 2 = long) */
802 false, /* pc_relative */
804 complain_overflow_bitfield
, /* complain_on_overflow */
805 0, /* special_function */
806 "DTPMOD64", /* name */
807 false, /* partial_inplace */
808 MINUS_ONE
, /* src_mask */
809 MINUS_ONE
, /* dst_mask */
810 false), /* pcrel_offset */
812 /* Creates a 64-bit offset in the got for the displacement
813 from DTP to the target. */
814 HOWTO (R_ALPHA_GOTDTPREL
, /* type */
816 1, /* size (0 = byte, 1 = short, 2 = long) */
818 false, /* pc_relative */
820 complain_overflow_signed
, /* complain_on_overflow */
821 0, /* special_function */
822 "GOTDTPREL", /* name */
823 false, /* partial_inplace */
824 0xffff, /* src_mask */
825 0xffff, /* dst_mask */
826 false), /* pcrel_offset */
828 /* A dynamic relocation for a displacement from DTP to the target. */
829 HOWTO (R_ALPHA_DTPREL64
, /* type */
831 4, /* size (0 = byte, 1 = short, 2 = long) */
833 false, /* pc_relative */
835 complain_overflow_bitfield
, /* complain_on_overflow */
836 0, /* special_function */
837 "DTPREL64", /* name */
838 false, /* partial_inplace */
839 MINUS_ONE
, /* src_mask */
840 MINUS_ONE
, /* dst_mask */
841 false), /* pcrel_offset */
843 /* The high 16 bits of the displacement from DTP to the target. */
844 HOWTO (R_ALPHA_DTPRELHI
, /* type */
846 1, /* size (0 = byte, 1 = short, 2 = long) */
848 false, /* pc_relative */
850 complain_overflow_signed
, /* complain_on_overflow */
851 0, /* special_function */
852 "DTPRELHI", /* name */
853 false, /* partial_inplace */
854 0xffff, /* src_mask */
855 0xffff, /* dst_mask */
856 false), /* pcrel_offset */
858 /* The low 16 bits of the displacement from DTP to the target. */
859 HOWTO (R_ALPHA_DTPRELLO
, /* type */
861 1, /* size (0 = byte, 1 = short, 2 = long) */
863 false, /* pc_relative */
865 complain_overflow_dont
, /* complain_on_overflow */
866 0, /* special_function */
867 "DTPRELLO", /* name */
868 false, /* partial_inplace */
869 0xffff, /* src_mask */
870 0xffff, /* dst_mask */
871 false), /* pcrel_offset */
873 /* A 16-bit displacement from DTP to the target. */
874 HOWTO (R_ALPHA_DTPREL16
, /* type */
876 1, /* size (0 = byte, 1 = short, 2 = long) */
878 false, /* pc_relative */
880 complain_overflow_signed
, /* complain_on_overflow */
881 0, /* special_function */
882 "DTPREL16", /* name */
883 false, /* partial_inplace */
884 0xffff, /* src_mask */
885 0xffff, /* dst_mask */
886 false), /* pcrel_offset */
888 /* Creates a 64-bit offset in the got for the displacement
889 from TP to the target. */
890 HOWTO (R_ALPHA_GOTTPREL
, /* type */
892 1, /* size (0 = byte, 1 = short, 2 = long) */
894 false, /* pc_relative */
896 complain_overflow_signed
, /* complain_on_overflow */
897 0, /* special_function */
898 "GOTTPREL", /* name */
899 false, /* partial_inplace */
900 0xffff, /* src_mask */
901 0xffff, /* dst_mask */
902 false), /* pcrel_offset */
904 /* A dynamic relocation for a displacement from TP to the target. */
905 HOWTO (R_ALPHA_TPREL64
, /* type */
907 4, /* size (0 = byte, 1 = short, 2 = long) */
909 false, /* pc_relative */
911 complain_overflow_bitfield
, /* complain_on_overflow */
912 0, /* special_function */
913 "TPREL64", /* name */
914 false, /* partial_inplace */
915 MINUS_ONE
, /* src_mask */
916 MINUS_ONE
, /* dst_mask */
917 false), /* pcrel_offset */
919 /* The high 16 bits of the displacement from TP to the target. */
920 HOWTO (R_ALPHA_TPRELHI
, /* type */
922 1, /* size (0 = byte, 1 = short, 2 = long) */
924 false, /* pc_relative */
926 complain_overflow_signed
, /* complain_on_overflow */
927 0, /* special_function */
928 "TPRELHI", /* name */
929 false, /* partial_inplace */
930 0xffff, /* src_mask */
931 0xffff, /* dst_mask */
932 false), /* pcrel_offset */
934 /* The low 16 bits of the displacement from TP to the target. */
935 HOWTO (R_ALPHA_TPRELLO
, /* type */
937 1, /* size (0 = byte, 1 = short, 2 = long) */
939 false, /* pc_relative */
941 complain_overflow_dont
, /* complain_on_overflow */
942 0, /* special_function */
943 "TPRELLO", /* name */
944 false, /* partial_inplace */
945 0xffff, /* src_mask */
946 0xffff, /* dst_mask */
947 false), /* pcrel_offset */
949 /* A 16-bit displacement from TP to the target. */
950 HOWTO (R_ALPHA_TPREL16
, /* type */
952 1, /* size (0 = byte, 1 = short, 2 = long) */
954 false, /* pc_relative */
956 complain_overflow_signed
, /* complain_on_overflow */
957 0, /* special_function */
958 "TPREL16", /* name */
959 false, /* partial_inplace */
960 0xffff, /* src_mask */
961 0xffff, /* dst_mask */
962 false), /* pcrel_offset */
965 /* A relocation function which doesn't do anything. */
967 static bfd_reloc_status_type
968 elf64_alpha_reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
969 bfd
*abfd ATTRIBUTE_UNUSED
;
971 asymbol
*sym ATTRIBUTE_UNUSED
;
972 PTR data ATTRIBUTE_UNUSED
;
975 char **error_message ATTRIBUTE_UNUSED
;
978 reloc
->address
+= sec
->output_offset
;
982 /* A relocation function used for an unsupported reloc. */
984 static bfd_reloc_status_type
985 elf64_alpha_reloc_bad (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
986 bfd
*abfd ATTRIBUTE_UNUSED
;
988 asymbol
*sym ATTRIBUTE_UNUSED
;
989 PTR data ATTRIBUTE_UNUSED
;
992 char **error_message ATTRIBUTE_UNUSED
;
995 reloc
->address
+= sec
->output_offset
;
996 return bfd_reloc_notsupported
;
999 /* Do the work of the GPDISP relocation. */
1001 static bfd_reloc_status_type
1002 elf64_alpha_do_reloc_gpdisp (abfd
, gpdisp
, p_ldah
, p_lda
)
1008 bfd_reloc_status_type ret
= bfd_reloc_ok
;
1010 unsigned long i_ldah
, i_lda
;
1012 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
1013 i_lda
= bfd_get_32 (abfd
, p_lda
);
1015 /* Complain if the instructions are not correct. */
1016 if (((i_ldah
>> 26) & 0x3f) != 0x09
1017 || ((i_lda
>> 26) & 0x3f) != 0x08)
1018 ret
= bfd_reloc_dangerous
;
1020 /* Extract the user-supplied offset, mirroring the sign extensions
1021 that the instructions perform. */
1022 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
1023 addend
= (addend
^ 0x80008000) - 0x80008000;
1027 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
1028 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
1029 ret
= bfd_reloc_overflow
;
1031 /* compensate for the sign extension again. */
1032 i_ldah
= ((i_ldah
& 0xffff0000)
1033 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
1034 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
1036 bfd_put_32 (abfd
, (bfd_vma
) i_ldah
, p_ldah
);
1037 bfd_put_32 (abfd
, (bfd_vma
) i_lda
, p_lda
);
1042 /* The special function for the GPDISP reloc. */
1044 static bfd_reloc_status_type
1045 elf64_alpha_reloc_gpdisp (abfd
, reloc_entry
, sym
, data
, input_section
,
1046 output_bfd
, err_msg
)
1048 arelent
*reloc_entry
;
1049 asymbol
*sym ATTRIBUTE_UNUSED
;
1051 asection
*input_section
;
1055 bfd_reloc_status_type ret
;
1056 bfd_vma gp
, relocation
;
1057 bfd_byte
*p_ldah
, *p_lda
;
1059 /* Don't do anything if we're not doing a final link. */
1062 reloc_entry
->address
+= input_section
->output_offset
;
1063 return bfd_reloc_ok
;
1066 if (reloc_entry
->address
> input_section
->_cooked_size
||
1067 reloc_entry
->address
+ reloc_entry
->addend
> input_section
->_cooked_size
)
1068 return bfd_reloc_outofrange
;
1070 /* The gp used in the portion of the output object to which this
1071 input object belongs is cached on the input bfd. */
1072 gp
= _bfd_get_gp_value (abfd
);
1074 relocation
= (input_section
->output_section
->vma
1075 + input_section
->output_offset
1076 + reloc_entry
->address
);
1078 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
1079 p_lda
= p_ldah
+ reloc_entry
->addend
;
1081 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
1083 /* Complain if the instructions are not correct. */
1084 if (ret
== bfd_reloc_dangerous
)
1085 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
1090 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1092 struct elf_reloc_map
1094 bfd_reloc_code_real_type bfd_reloc_val
;
1098 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
1100 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
1101 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
1102 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
1103 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
1104 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
1105 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
1106 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
1107 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
1108 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
1109 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
1110 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
1111 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
1112 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
1113 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
1114 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
1115 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
1116 {BFD_RELOC_ALPHA_BRSGP
, R_ALPHA_BRSGP
},
1117 {BFD_RELOC_ALPHA_TLSGD
, R_ALPHA_TLSGD
},
1118 {BFD_RELOC_ALPHA_TLSLDM
, R_ALPHA_TLSLDM
},
1119 {BFD_RELOC_ALPHA_DTPMOD64
, R_ALPHA_DTPMOD64
},
1120 {BFD_RELOC_ALPHA_GOTDTPREL16
, R_ALPHA_GOTDTPREL
},
1121 {BFD_RELOC_ALPHA_DTPREL64
, R_ALPHA_DTPREL64
},
1122 {BFD_RELOC_ALPHA_DTPREL_HI16
, R_ALPHA_DTPRELHI
},
1123 {BFD_RELOC_ALPHA_DTPREL_LO16
, R_ALPHA_DTPRELLO
},
1124 {BFD_RELOC_ALPHA_DTPREL16
, R_ALPHA_DTPREL16
},
1125 {BFD_RELOC_ALPHA_GOTTPREL16
, R_ALPHA_GOTTPREL
},
1126 {BFD_RELOC_ALPHA_TPREL64
, R_ALPHA_TPREL64
},
1127 {BFD_RELOC_ALPHA_TPREL_HI16
, R_ALPHA_TPRELHI
},
1128 {BFD_RELOC_ALPHA_TPREL_LO16
, R_ALPHA_TPRELLO
},
1129 {BFD_RELOC_ALPHA_TPREL16
, R_ALPHA_TPREL16
},
1132 /* Given a BFD reloc type, return a HOWTO structure. */
1134 static reloc_howto_type
*
1135 elf64_alpha_bfd_reloc_type_lookup (abfd
, code
)
1136 bfd
*abfd ATTRIBUTE_UNUSED
;
1137 bfd_reloc_code_real_type code
;
1139 const struct elf_reloc_map
*i
, *e
;
1140 i
= e
= elf64_alpha_reloc_map
;
1141 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1144 if (i
->bfd_reloc_val
== code
)
1145 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1150 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1153 elf64_alpha_info_to_howto (abfd
, cache_ptr
, dst
)
1154 bfd
*abfd ATTRIBUTE_UNUSED
;
1156 Elf64_Internal_Rela
*dst
;
1160 r_type
= ELF64_R_TYPE(dst
->r_info
);
1161 BFD_ASSERT (r_type
< (unsigned int) R_ALPHA_max
);
1162 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1165 /* These two relocations create a two-word entry in the got. */
1166 #define alpha_got_entry_size(r_type) \
1167 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1169 /* These functions do relaxation for Alpha ELF.
1171 Currently I'm only handling what I can do with existing compiler
1172 and assembler support, which means no instructions are removed,
1173 though some may be nopped. At this time GCC does not emit enough
1174 information to do all of the relaxing that is possible. It will
1175 take some not small amount of work for that to happen.
1177 There are a couple of interesting papers that I once read on this
1178 subject, that I cannot find references to at the moment, that
1179 related to Alpha in particular. They are by David Wall, then of
1183 #define OP_LDAH 0x09
1184 #define INSN_JSR 0x68004000
1185 #define INSN_JSR_MASK 0xfc00c000
1189 #define INSN_UNOP 0x2ffe0000
1191 struct alpha_relax_info
1196 Elf_Internal_Rela
*relocs
, *relend
;
1197 struct bfd_link_info
*link_info
;
1198 boolean changed_contents
;
1199 boolean changed_relocs
;
1203 struct alpha_elf_link_hash_entry
*h
;
1204 struct alpha_elf_got_entry
*gotent
;
1205 unsigned char other
;
1208 static Elf_Internal_Rela
* elf64_alpha_relax_with_lituse
1209 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1210 Elf_Internal_Rela
*irel
, Elf_Internal_Rela
*irelend
));
1212 static boolean elf64_alpha_relax_without_lituse
1213 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1214 Elf_Internal_Rela
*irel
));
1216 static bfd_vma elf64_alpha_relax_opt_call
1217 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
));
1219 static boolean elf64_alpha_relax_section
1220 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
1223 static Elf_Internal_Rela
*
1224 elf64_alpha_find_reloc_at_ofs (rel
, relend
, offset
, type
)
1225 Elf_Internal_Rela
*rel
, *relend
;
1229 while (rel
< relend
)
1231 if (rel
->r_offset
== offset
1232 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
1239 static Elf_Internal_Rela
*
1240 elf64_alpha_relax_with_lituse (info
, symval
, irel
, irelend
)
1241 struct alpha_relax_info
*info
;
1243 Elf_Internal_Rela
*irel
, *irelend
;
1245 Elf_Internal_Rela
*urel
;
1246 int flags
, count
, i
;
1247 bfd_signed_vma disp
;
1250 boolean lit_reused
= false;
1251 boolean all_optimized
= true;
1252 unsigned int lit_insn
;
1254 lit_insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1255 if (lit_insn
>> 26 != OP_LDQ
)
1257 ((*_bfd_error_handler
)
1258 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1259 bfd_archive_filename (info
->abfd
), info
->sec
->name
,
1260 (unsigned long) irel
->r_offset
));
1264 /* Summarize how this particular LITERAL is used. */
1265 for (urel
= irel
+1, flags
= count
= 0; urel
< irelend
; ++urel
, ++count
)
1267 if (ELF64_R_TYPE (urel
->r_info
) != R_ALPHA_LITUSE
)
1269 if (urel
->r_addend
<= 3)
1270 flags
|= 1 << urel
->r_addend
;
1273 /* A little preparation for the loop... */
1274 disp
= symval
- info
->gp
;
1276 for (urel
= irel
+1, i
= 0; i
< count
; ++i
, ++urel
)
1280 bfd_signed_vma xdisp
;
1282 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ urel
->r_offset
);
1284 switch (urel
->r_addend
)
1286 default: /* 0 = ADDRESS FORMAT */
1287 /* This type is really just a placeholder to note that all
1288 uses cannot be optimized, but to still allow some. */
1289 all_optimized
= false;
1292 case 1: /* MEM FORMAT */
1293 /* We can always optimize 16-bit displacements. */
1295 /* Extract the displacement from the instruction, sign-extending
1296 it if necessary, then test whether it is within 16 or 32 bits
1297 displacement from GP. */
1298 insn_disp
= insn
& 0x0000ffff;
1299 if (insn_disp
& 0x00008000)
1300 insn_disp
|= 0xffff0000; /* Negative: sign-extend. */
1302 xdisp
= disp
+ insn_disp
;
1303 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x00008000 && xdisp
< 0x00008000);
1304 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000 && xdisp
< 0x7fff8000);
1308 /* Take the op code and dest from this insn, take the base
1309 register from the literal insn. Leave the offset alone. */
1310 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
1311 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1313 urel
->r_addend
= irel
->r_addend
;
1314 info
->changed_relocs
= true;
1316 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1317 info
->contents
+ urel
->r_offset
);
1318 info
->changed_contents
= true;
1321 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1322 else if (fits32
&& !(flags
& ~6))
1324 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1326 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1328 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
1329 bfd_put_32 (info
->abfd
, (bfd_vma
) lit_insn
,
1330 info
->contents
+ irel
->r_offset
);
1332 info
->changed_contents
= true;
1334 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1336 urel
->r_addend
= irel
->r_addend
;
1337 info
->changed_relocs
= true;
1340 all_optimized
= false;
1343 case 2: /* BYTE OFFSET FORMAT */
1344 /* We can always optimize byte instructions. */
1346 /* FIXME: sanity check the insn for byte op. Check that the
1347 literal dest reg is indeed Rb in the byte insn. */
1349 insn
&= ~ (unsigned) 0x001ff000;
1350 insn
|= ((symval
& 7) << 13) | 0x1000;
1352 urel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1354 info
->changed_relocs
= true;
1356 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1357 info
->contents
+ urel
->r_offset
);
1358 info
->changed_contents
= true;
1361 case 3: /* CALL FORMAT */
1363 /* If not zero, place to jump without needing pv. */
1364 bfd_vma optdest
= elf64_alpha_relax_opt_call (info
, symval
);
1365 bfd_vma org
= (info
->sec
->output_section
->vma
1366 + info
->sec
->output_offset
1367 + urel
->r_offset
+ 4);
1368 bfd_signed_vma odisp
;
1370 odisp
= (optdest
? optdest
: symval
) - org
;
1371 if (odisp
>= -0x400000 && odisp
< 0x400000)
1373 Elf_Internal_Rela
*xrel
;
1375 /* Preserve branch prediction call stack when possible. */
1376 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
1377 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
1379 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
1381 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1383 urel
->r_addend
= irel
->r_addend
;
1386 urel
->r_addend
+= optdest
- symval
;
1388 all_optimized
= false;
1390 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1391 info
->contents
+ urel
->r_offset
);
1393 /* Kill any HINT reloc that might exist for this insn. */
1394 xrel
= (elf64_alpha_find_reloc_at_ofs
1395 (info
->relocs
, info
->relend
, urel
->r_offset
,
1398 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1400 info
->changed_contents
= true;
1401 info
->changed_relocs
= true;
1404 all_optimized
= false;
1406 /* Even if the target is not in range for a direct branch,
1407 if we share a GP, we can eliminate the gp reload. */
1410 Elf_Internal_Rela
*gpdisp
1411 = (elf64_alpha_find_reloc_at_ofs
1412 (irel
, irelend
, urel
->r_offset
+ 4, R_ALPHA_GPDISP
));
1415 bfd_byte
*p_ldah
= info
->contents
+ gpdisp
->r_offset
;
1416 bfd_byte
*p_lda
= p_ldah
+ gpdisp
->r_addend
;
1417 unsigned int ldah
= bfd_get_32 (info
->abfd
, p_ldah
);
1418 unsigned int lda
= bfd_get_32 (info
->abfd
, p_lda
);
1420 /* Verify that the instruction is "ldah $29,0($26)".
1421 Consider a function that ends in a noreturn call,
1422 and that the next function begins with an ldgp,
1423 and that by accident there is no padding between.
1424 In that case the insn would use $27 as the base. */
1425 if (ldah
== 0x27ba0000 && lda
== 0x23bd0000)
1427 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_ldah
);
1428 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_lda
);
1430 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1431 info
->changed_contents
= true;
1432 info
->changed_relocs
= true;
1441 /* If all cases were optimized, we can reduce the use count on this
1442 got entry by one, possibly eliminating it. */
1445 if (--info
->gotent
->use_count
== 0)
1447 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
1448 alpha_elf_tdata (info
->gotent
->gotobj
)->total_got_size
-= sz
;
1450 alpha_elf_tdata (info
->gotent
->gotobj
)->local_got_size
-= sz
;
1453 /* If the literal instruction is no longer needed (it may have been
1454 reused. We can eliminate it. */
1455 /* ??? For now, I don't want to deal with compacting the section,
1456 so just nop it out. */
1459 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1460 info
->changed_relocs
= true;
1462 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
,
1463 info
->contents
+ irel
->r_offset
);
1464 info
->changed_contents
= true;
1468 return irel
+ count
;
1472 elf64_alpha_relax_opt_call (info
, symval
)
1473 struct alpha_relax_info
*info
;
1476 /* If the function has the same gp, and we can identify that the
1477 function does not use its function pointer, we can eliminate the
1480 /* If the symbol is marked NOPV, we are being told the function never
1481 needs its procedure value. */
1482 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
1485 /* If the symbol is marked STD_GP, we are being told the function does
1486 a normal ldgp in the first two words. */
1487 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
1490 /* Otherwise, we may be able to identify a GP load in the first two
1491 words, which we can then skip. */
1494 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
1497 /* Load the relocations from the section that the target symbol is in. */
1498 if (info
->sec
== info
->tsec
)
1500 tsec_relocs
= info
->relocs
;
1501 tsec_relend
= info
->relend
;
1506 tsec_relocs
= (_bfd_elf64_link_read_relocs
1507 (info
->abfd
, info
->tsec
, (PTR
) NULL
,
1508 (Elf_Internal_Rela
*) NULL
,
1509 info
->link_info
->keep_memory
));
1510 if (tsec_relocs
== NULL
)
1512 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
1513 tsec_free
= (info
->link_info
->keep_memory
? NULL
: tsec_relocs
);
1516 /* Recover the symbol's offset within the section. */
1517 ofs
= (symval
- info
->tsec
->output_section
->vma
1518 - info
->tsec
->output_offset
);
1520 /* Look for a GPDISP reloc. */
1521 gpdisp
= (elf64_alpha_find_reloc_at_ofs
1522 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
1524 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
1534 /* We've now determined that we can skip an initial gp load. Verify
1535 that the call and the target use the same gp. */
1536 if (info
->link_info
->hash
->creator
!= info
->tsec
->owner
->xvec
1537 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
1544 elf64_alpha_relax_without_lituse (info
, symval
, irel
)
1545 struct alpha_relax_info
*info
;
1547 Elf_Internal_Rela
*irel
;
1550 bfd_signed_vma disp
;
1552 /* Get the instruction. */
1553 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1555 if (insn
>> 26 != OP_LDQ
)
1557 ((*_bfd_error_handler
)
1558 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1559 bfd_archive_filename (info
->abfd
), info
->sec
->name
,
1560 (unsigned long) irel
->r_offset
));
1564 /* So we aren't told much. Do what we can with the address load and
1565 fake the rest. All of the optimizations here require that the
1566 offset from the GP fit in 16 bits. */
1568 disp
= symval
- info
->gp
;
1569 if (disp
< -0x8000 || disp
>= 0x8000)
1572 /* On the LITERAL instruction itself, consider exchanging
1573 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1575 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
1576 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, info
->contents
+ irel
->r_offset
);
1577 info
->changed_contents
= true;
1579 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), R_ALPHA_GPREL16
);
1580 info
->changed_relocs
= true;
1582 /* Reduce the use count on this got entry by one, possibly
1584 if (--info
->gotent
->use_count
== 0)
1586 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
1587 alpha_elf_tdata (info
->gotent
->gotobj
)->total_got_size
-= sz
;
1589 alpha_elf_tdata (info
->gotent
->gotobj
)->local_got_size
-= sz
;
1592 /* ??? Search forward through this basic block looking for insns
1593 that use the target register. Stop after an insn modifying the
1594 register is seen, or after a branch or call.
1596 Any such memory load insn may be substituted by a load directly
1597 off the GP. This allows the memory load insn to be issued before
1598 the calculated GP register would otherwise be ready.
1600 Any such jsr insn can be replaced by a bsr if it is in range.
1602 This would mean that we'd have to _add_ relocations, the pain of
1603 which gives one pause. */
1609 elf64_alpha_relax_section (abfd
, sec
, link_info
, again
)
1612 struct bfd_link_info
*link_info
;
1615 Elf_Internal_Shdr
*symtab_hdr
;
1616 Elf_Internal_Shdr
*shndx_hdr
;
1617 Elf_Internal_Rela
*internal_relocs
;
1618 Elf_Internal_Rela
*free_relocs
= NULL
;
1619 Elf_Internal_Rela
*irel
, *irelend
;
1620 bfd_byte
*free_contents
= NULL
;
1621 Elf64_External_Sym
*extsyms
= NULL
;
1622 Elf64_External_Sym
*free_extsyms
= NULL
;
1623 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1624 struct alpha_elf_got_entry
**local_got_entries
;
1625 struct alpha_relax_info info
;
1627 /* We are not currently changing any sizes, so only one pass. */
1630 if (link_info
->relocateable
1631 || (sec
->flags
& SEC_RELOC
) == 0
1632 || sec
->reloc_count
== 0)
1635 /* If this is the first time we have been called for this section,
1636 initialize the cooked size. */
1637 if (sec
->_cooked_size
== 0)
1638 sec
->_cooked_size
= sec
->_raw_size
;
1640 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1641 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1643 /* Load the relocations for this section. */
1644 internal_relocs
= (_bfd_elf64_link_read_relocs
1645 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1646 link_info
->keep_memory
));
1647 if (internal_relocs
== NULL
)
1649 if (! link_info
->keep_memory
)
1650 free_relocs
= internal_relocs
;
1652 memset(&info
, 0, sizeof (info
));
1655 info
.link_info
= link_info
;
1656 info
.relocs
= internal_relocs
;
1657 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
1659 /* Find the GP for this object. Do not store the result back via
1660 _bfd_set_gp_value, since this could change again before final. */
1661 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
1664 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
1665 info
.gp
= (sgot
->output_section
->vma
1666 + sgot
->output_offset
1670 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1673 Elf_Internal_Sym isym
;
1674 struct alpha_elf_got_entry
*gotent
;
1676 if (ELF64_R_TYPE (irel
->r_info
) != (int) R_ALPHA_LITERAL
)
1679 /* Get the section contents. */
1680 if (info
.contents
== NULL
)
1682 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1683 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
1686 info
.contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
1687 if (info
.contents
== NULL
)
1689 free_contents
= info
.contents
;
1691 if (! bfd_get_section_contents (abfd
, sec
, info
.contents
,
1692 (file_ptr
) 0, sec
->_raw_size
))
1697 /* Read this BFD's symbols if we haven't done so already. */
1698 if (extsyms
== NULL
)
1702 if (symtab_hdr
->contents
!= NULL
)
1703 extsyms
= (Elf64_External_Sym
*) symtab_hdr
->contents
;
1706 amt
= symtab_hdr
->sh_info
;
1707 amt
*= sizeof (Elf64_External_Sym
);
1708 extsyms
= (Elf64_External_Sym
*) bfd_malloc (amt
);
1709 if (extsyms
== NULL
)
1711 free_extsyms
= extsyms
;
1712 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1713 || bfd_bread ((PTR
) extsyms
, amt
, abfd
) != amt
)
1717 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1718 if (shndx_hdr
->sh_size
!= 0)
1720 amt
= symtab_hdr
->sh_info
;
1721 amt
*= sizeof (Elf_External_Sym_Shndx
);
1722 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1723 if (shndx_buf
== NULL
)
1725 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1726 || bfd_bread ((PTR
) shndx_buf
, amt
, abfd
) != amt
)
1731 /* Get the value of the symbol referred to by the reloc. */
1732 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1734 /* A local symbol. */
1735 Elf64_External_Sym
*esym
;
1736 Elf_External_Sym_Shndx
*shndx
;
1738 esym
= extsyms
+ ELF64_R_SYM (irel
->r_info
);
1739 shndx
= shndx_buf
+ (shndx_buf
? ELF64_R_SYM (irel
->r_info
) : 0);
1740 bfd_elf64_swap_symbol_in (abfd
, esym
, shndx
, &isym
);
1741 if (isym
.st_shndx
== SHN_UNDEF
)
1742 info
.tsec
= bfd_und_section_ptr
;
1743 else if (isym
.st_shndx
== SHN_ABS
)
1744 info
.tsec
= bfd_abs_section_ptr
;
1745 else if (isym
.st_shndx
== SHN_COMMON
)
1746 info
.tsec
= bfd_com_section_ptr
;
1748 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
1751 info
.other
= isym
.st_other
;
1752 gotent
= local_got_entries
[ELF64_R_SYM(irel
->r_info
)];
1753 symval
= isym
.st_value
;
1758 struct alpha_elf_link_hash_entry
*h
;
1760 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1761 h
= alpha_elf_sym_hashes (abfd
)[indx
];
1762 BFD_ASSERT (h
!= NULL
);
1764 while (h
->root
.root
.type
== bfd_link_hash_indirect
1765 || h
->root
.root
.type
== bfd_link_hash_warning
)
1766 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1768 /* We can't do anthing with undefined or dynamic symbols. */
1769 if (h
->root
.root
.type
== bfd_link_hash_undefined
1770 || h
->root
.root
.type
== bfd_link_hash_undefweak
1771 || alpha_elf_dynamic_symbol_p (&h
->root
, link_info
))
1775 info
.tsec
= h
->root
.root
.u
.def
.section
;
1776 info
.other
= h
->root
.other
;
1777 gotent
= h
->got_entries
;
1778 symval
= h
->root
.root
.u
.def
.value
;
1781 /* Search for the got entry to be used by this relocation. */
1782 while (gotent
->gotobj
!= info
.gotobj
|| gotent
->addend
!= irel
->r_addend
)
1783 gotent
= gotent
->next
;
1784 info
.gotent
= gotent
;
1786 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
1787 symval
+= irel
->r_addend
;
1789 BFD_ASSERT(info
.gotent
!= NULL
);
1791 /* If there exist LITUSE relocations immediately following, this
1792 opens up all sorts of interesting optimizations, because we
1793 now know every location that this address load is used. */
1795 if (irel
+1 < irelend
&& ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
1797 irel
= elf64_alpha_relax_with_lituse (&info
, symval
, irel
, irelend
);
1803 if (!elf64_alpha_relax_without_lituse (&info
, symval
, irel
))
1808 if (!elf64_alpha_size_got_sections (abfd
, link_info
))
1811 if (info
.changed_relocs
)
1813 elf_section_data (sec
)->relocs
= internal_relocs
;
1815 else if (free_relocs
!= NULL
)
1820 if (info
.changed_contents
)
1822 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
1824 else if (free_contents
!= NULL
)
1826 if (! link_info
->keep_memory
)
1827 free (free_contents
);
1830 /* Cache the section contents for elf_link_input_bfd. */
1831 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
1835 if (shndx_buf
!= NULL
)
1838 if (free_extsyms
!= NULL
)
1840 if (! link_info
->keep_memory
)
1841 free (free_extsyms
);
1844 /* Cache the symbols for elf_link_input_bfd. */
1845 symtab_hdr
->contents
= (unsigned char *) extsyms
;
1849 *again
= info
.changed_contents
|| info
.changed_relocs
;
1854 if (free_relocs
!= NULL
)
1856 if (free_contents
!= NULL
)
1857 free (free_contents
);
1858 if (shndx_buf
!= NULL
)
1860 if (free_extsyms
!= NULL
)
1861 free (free_extsyms
);
1866 #define PLT_HEADER_SIZE 32
1867 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
1868 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
1869 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
1870 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
1872 #define PLT_ENTRY_SIZE 12
1873 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1874 #define PLT_ENTRY_WORD2 0
1875 #define PLT_ENTRY_WORD3 0
1877 #define MAX_GOT_SIZE (64*1024)
1879 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1881 /* Handle an Alpha specific section when reading an object file. This
1882 is called when elfcode.h finds a section with an unknown type.
1883 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1887 elf64_alpha_section_from_shdr (abfd
, hdr
, name
)
1889 Elf64_Internal_Shdr
*hdr
;
1894 /* There ought to be a place to keep ELF backend specific flags, but
1895 at the moment there isn't one. We just keep track of the
1896 sections by their name, instead. Fortunately, the ABI gives
1897 suggested names for all the MIPS specific sections, so we will
1898 probably get away with this. */
1899 switch (hdr
->sh_type
)
1901 case SHT_ALPHA_DEBUG
:
1902 if (strcmp (name
, ".mdebug") != 0)
1909 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1911 newsect
= hdr
->bfd_section
;
1913 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
1915 if (! bfd_set_section_flags (abfd
, newsect
,
1916 (bfd_get_section_flags (abfd
, newsect
)
1924 /* Convert Alpha specific section flags to bfd internal section flags. */
1927 elf64_alpha_section_flags (flags
, hdr
)
1929 Elf64_Internal_Shdr
*hdr
;
1931 if (hdr
->sh_flags
& SHF_ALPHA_GPREL
)
1932 *flags
|= SEC_SMALL_DATA
;
1937 /* Set the correct type for an Alpha ELF section. We do this by the
1938 section name, which is a hack, but ought to work. */
1941 elf64_alpha_fake_sections (abfd
, hdr
, sec
)
1943 Elf64_Internal_Shdr
*hdr
;
1946 register const char *name
;
1948 name
= bfd_get_section_name (abfd
, sec
);
1950 if (strcmp (name
, ".mdebug") == 0)
1952 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
1953 /* In a shared object on Irix 5.3, the .mdebug section has an
1954 entsize of 0. FIXME: Does this matter? */
1955 if ((abfd
->flags
& DYNAMIC
) != 0 )
1956 hdr
->sh_entsize
= 0;
1958 hdr
->sh_entsize
= 1;
1960 else if ((sec
->flags
& SEC_SMALL_DATA
)
1961 || strcmp (name
, ".sdata") == 0
1962 || strcmp (name
, ".sbss") == 0
1963 || strcmp (name
, ".lit4") == 0
1964 || strcmp (name
, ".lit8") == 0)
1965 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
1970 /* Hook called by the linker routine which adds symbols from an object
1971 file. We use it to put .comm items in .sbss, and not .bss. */
1974 elf64_alpha_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1976 struct bfd_link_info
*info
;
1977 const Elf_Internal_Sym
*sym
;
1978 const char **namep ATTRIBUTE_UNUSED
;
1979 flagword
*flagsp ATTRIBUTE_UNUSED
;
1983 if (sym
->st_shndx
== SHN_COMMON
1984 && !info
->relocateable
1985 && sym
->st_size
<= elf_gp_size (abfd
))
1987 /* Common symbols less than or equal to -G nn bytes are
1988 automatically put into .sbss. */
1990 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1994 scomm
= bfd_make_section (abfd
, ".scommon");
1996 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1998 | SEC_LINKER_CREATED
)))
2003 *valp
= sym
->st_size
;
2009 /* Create the .got section. */
2012 elf64_alpha_create_got_section(abfd
, info
)
2014 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2018 if (bfd_get_section_by_name (abfd
, ".got"))
2021 s
= bfd_make_section (abfd
, ".got");
2023 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2026 | SEC_LINKER_CREATED
))
2027 || !bfd_set_section_alignment (abfd
, s
, 3))
2030 alpha_elf_tdata (abfd
)->got
= s
;
2035 /* Create all the dynamic sections. */
2038 elf64_alpha_create_dynamic_sections (abfd
, info
)
2040 struct bfd_link_info
*info
;
2043 struct elf_link_hash_entry
*h
;
2045 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2047 s
= bfd_make_section (abfd
, ".plt");
2049 || ! bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2052 | SEC_LINKER_CREATED
2054 || ! bfd_set_section_alignment (abfd
, s
, 3))
2057 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2060 if (! (_bfd_generic_link_add_one_symbol
2061 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2062 (bfd_vma
) 0, (const char *) NULL
, false,
2063 get_elf_backend_data (abfd
)->collect
,
2064 (struct bfd_link_hash_entry
**) &h
)))
2066 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2067 h
->type
= STT_OBJECT
;
2070 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2073 s
= bfd_make_section (abfd
, ".rela.plt");
2075 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2078 | SEC_LINKER_CREATED
2080 || ! bfd_set_section_alignment (abfd
, s
, 3))
2083 /* We may or may not have created a .got section for this object, but
2084 we definitely havn't done the rest of the work. */
2086 if (!elf64_alpha_create_got_section (abfd
, info
))
2089 s
= bfd_make_section(abfd
, ".rela.got");
2091 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2094 | SEC_LINKER_CREATED
2096 || !bfd_set_section_alignment (abfd
, s
, 3))
2099 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2100 dynobj's .got section. We don't do this in the linker script
2101 because we don't want to define the symbol if we are not creating
2102 a global offset table. */
2104 if (!(_bfd_generic_link_add_one_symbol
2105 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
,
2106 alpha_elf_tdata(abfd
)->got
, (bfd_vma
) 0, (const char *) NULL
,
2107 false, get_elf_backend_data (abfd
)->collect
,
2108 (struct bfd_link_hash_entry
**) &h
)))
2110 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2111 h
->type
= STT_OBJECT
;
2114 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2117 elf_hash_table (info
)->hgot
= h
;
2122 /* Read ECOFF debugging information from a .mdebug section into a
2123 ecoff_debug_info structure. */
2126 elf64_alpha_read_ecoff_info (abfd
, section
, debug
)
2129 struct ecoff_debug_info
*debug
;
2132 const struct ecoff_debug_swap
*swap
;
2133 char *ext_hdr
= NULL
;
2135 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2136 memset (debug
, 0, sizeof (*debug
));
2138 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
2139 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2142 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2143 swap
->external_hdr_size
)
2147 symhdr
= &debug
->symbolic_header
;
2148 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2150 /* The symbolic header contains absolute file offsets and sizes to
2152 #define READ(ptr, offset, count, size, type) \
2153 if (symhdr->count == 0) \
2154 debug->ptr = NULL; \
2157 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2158 debug->ptr = (type) bfd_malloc (amt); \
2159 if (debug->ptr == NULL) \
2160 goto error_return; \
2161 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2162 || bfd_bread (debug->ptr, amt, abfd) != amt) \
2163 goto error_return; \
2166 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2167 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2168 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2169 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2170 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2171 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2173 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2174 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2175 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2176 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2177 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2181 debug
->adjust
= NULL
;
2186 if (ext_hdr
!= NULL
)
2188 if (debug
->line
!= NULL
)
2190 if (debug
->external_dnr
!= NULL
)
2191 free (debug
->external_dnr
);
2192 if (debug
->external_pdr
!= NULL
)
2193 free (debug
->external_pdr
);
2194 if (debug
->external_sym
!= NULL
)
2195 free (debug
->external_sym
);
2196 if (debug
->external_opt
!= NULL
)
2197 free (debug
->external_opt
);
2198 if (debug
->external_aux
!= NULL
)
2199 free (debug
->external_aux
);
2200 if (debug
->ss
!= NULL
)
2202 if (debug
->ssext
!= NULL
)
2203 free (debug
->ssext
);
2204 if (debug
->external_fdr
!= NULL
)
2205 free (debug
->external_fdr
);
2206 if (debug
->external_rfd
!= NULL
)
2207 free (debug
->external_rfd
);
2208 if (debug
->external_ext
!= NULL
)
2209 free (debug
->external_ext
);
2213 /* Alpha ELF local labels start with '$'. */
2216 elf64_alpha_is_local_label_name (abfd
, name
)
2217 bfd
*abfd ATTRIBUTE_UNUSED
;
2220 return name
[0] == '$';
2223 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2224 routine in order to handle the ECOFF debugging information. We
2225 still call this mips_elf_find_line because of the slot
2226 find_line_info in elf_obj_tdata is declared that way. */
2228 struct mips_elf_find_line
2230 struct ecoff_debug_info d
;
2231 struct ecoff_find_line i
;
2235 elf64_alpha_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2236 functionname_ptr
, line_ptr
)
2241 const char **filename_ptr
;
2242 const char **functionname_ptr
;
2243 unsigned int *line_ptr
;
2247 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2248 filename_ptr
, functionname_ptr
,
2250 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2253 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2257 struct mips_elf_find_line
*fi
;
2258 const struct ecoff_debug_swap
* const swap
=
2259 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2261 /* If we are called during a link, alpha_elf_final_link may have
2262 cleared the SEC_HAS_CONTENTS field. We force it back on here
2263 if appropriate (which it normally will be). */
2264 origflags
= msec
->flags
;
2265 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2266 msec
->flags
|= SEC_HAS_CONTENTS
;
2268 fi
= elf_tdata (abfd
)->find_line_info
;
2271 bfd_size_type external_fdr_size
;
2274 struct fdr
*fdr_ptr
;
2275 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
2277 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
2280 msec
->flags
= origflags
;
2284 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
2286 msec
->flags
= origflags
;
2290 /* Swap in the FDR information. */
2291 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
2292 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
2293 if (fi
->d
.fdr
== NULL
)
2295 msec
->flags
= origflags
;
2298 external_fdr_size
= swap
->external_fdr_size
;
2299 fdr_ptr
= fi
->d
.fdr
;
2300 fraw_src
= (char *) fi
->d
.external_fdr
;
2301 fraw_end
= (fraw_src
2302 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2303 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2304 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2306 elf_tdata (abfd
)->find_line_info
= fi
;
2308 /* Note that we don't bother to ever free this information.
2309 find_nearest_line is either called all the time, as in
2310 objdump -l, so the information should be saved, or it is
2311 rarely called, as in ld error messages, so the memory
2312 wasted is unimportant. Still, it would probably be a
2313 good idea for free_cached_info to throw it away. */
2316 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2317 &fi
->i
, filename_ptr
, functionname_ptr
,
2320 msec
->flags
= origflags
;
2324 msec
->flags
= origflags
;
2327 /* Fall back on the generic ELF find_nearest_line routine. */
2329 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2330 filename_ptr
, functionname_ptr
,
2334 /* Structure used to pass information to alpha_elf_output_extsym. */
2339 struct bfd_link_info
*info
;
2340 struct ecoff_debug_info
*debug
;
2341 const struct ecoff_debug_swap
*swap
;
2346 elf64_alpha_output_extsym (h
, data
)
2347 struct alpha_elf_link_hash_entry
*h
;
2350 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2352 asection
*sec
, *output_section
;
2354 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2355 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2357 if (h
->root
.indx
== -2)
2359 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2360 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2361 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2362 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2364 else if (einfo
->info
->strip
== strip_all
2365 || (einfo
->info
->strip
== strip_some
2366 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2367 h
->root
.root
.root
.string
,
2368 false, false) == NULL
))
2376 if (h
->esym
.ifd
== -2)
2379 h
->esym
.cobol_main
= 0;
2380 h
->esym
.weakext
= 0;
2381 h
->esym
.reserved
= 0;
2382 h
->esym
.ifd
= ifdNil
;
2383 h
->esym
.asym
.value
= 0;
2384 h
->esym
.asym
.st
= stGlobal
;
2386 if (h
->root
.root
.type
!= bfd_link_hash_defined
2387 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2388 h
->esym
.asym
.sc
= scAbs
;
2393 sec
= h
->root
.root
.u
.def
.section
;
2394 output_section
= sec
->output_section
;
2396 /* When making a shared library and symbol h is the one from
2397 the another shared library, OUTPUT_SECTION may be null. */
2398 if (output_section
== NULL
)
2399 h
->esym
.asym
.sc
= scUndefined
;
2402 name
= bfd_section_name (output_section
->owner
, output_section
);
2404 if (strcmp (name
, ".text") == 0)
2405 h
->esym
.asym
.sc
= scText
;
2406 else if (strcmp (name
, ".data") == 0)
2407 h
->esym
.asym
.sc
= scData
;
2408 else if (strcmp (name
, ".sdata") == 0)
2409 h
->esym
.asym
.sc
= scSData
;
2410 else if (strcmp (name
, ".rodata") == 0
2411 || strcmp (name
, ".rdata") == 0)
2412 h
->esym
.asym
.sc
= scRData
;
2413 else if (strcmp (name
, ".bss") == 0)
2414 h
->esym
.asym
.sc
= scBss
;
2415 else if (strcmp (name
, ".sbss") == 0)
2416 h
->esym
.asym
.sc
= scSBss
;
2417 else if (strcmp (name
, ".init") == 0)
2418 h
->esym
.asym
.sc
= scInit
;
2419 else if (strcmp (name
, ".fini") == 0)
2420 h
->esym
.asym
.sc
= scFini
;
2422 h
->esym
.asym
.sc
= scAbs
;
2426 h
->esym
.asym
.reserved
= 0;
2427 h
->esym
.asym
.index
= indexNil
;
2430 if (h
->root
.root
.type
== bfd_link_hash_common
)
2431 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2432 else if (h
->root
.root
.type
== bfd_link_hash_defined
2433 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2435 if (h
->esym
.asym
.sc
== scCommon
)
2436 h
->esym
.asym
.sc
= scBss
;
2437 else if (h
->esym
.asym
.sc
== scSCommon
)
2438 h
->esym
.asym
.sc
= scSBss
;
2440 sec
= h
->root
.root
.u
.def
.section
;
2441 output_section
= sec
->output_section
;
2442 if (output_section
!= NULL
)
2443 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2444 + sec
->output_offset
2445 + output_section
->vma
);
2447 h
->esym
.asym
.value
= 0;
2449 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2451 /* Set type and value for a symbol with a function stub. */
2452 h
->esym
.asym
.st
= stProc
;
2453 sec
= bfd_get_section_by_name (einfo
->abfd
, ".plt");
2455 h
->esym
.asym
.value
= 0;
2458 output_section
= sec
->output_section
;
2459 if (output_section
!= NULL
)
2460 h
->esym
.asym
.value
= (h
->root
.plt
.offset
2461 + sec
->output_offset
2462 + output_section
->vma
);
2464 h
->esym
.asym
.value
= 0;
2468 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2469 h
->root
.root
.root
.string
,
2472 einfo
->failed
= true;
2479 /* Search for and possibly create a got entry. */
2481 static struct alpha_elf_got_entry
*
2482 get_got_entry (abfd
, h
, r_type
, r_symndx
, r_addend
)
2484 struct alpha_elf_link_hash_entry
*h
;
2485 unsigned long r_type
, r_symndx
;
2488 struct alpha_elf_got_entry
*gotent
;
2489 struct alpha_elf_got_entry
**slot
;
2492 slot
= &h
->got_entries
;
2495 /* This is a local .got entry -- record for merge. */
2497 struct alpha_elf_got_entry
**local_got_entries
;
2499 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2500 if (!local_got_entries
)
2503 Elf_Internal_Shdr
*symtab_hdr
;
2505 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2506 size
= symtab_hdr
->sh_info
;
2507 size
*= sizeof (struct alpha_elf_got_entry
*);
2510 = (struct alpha_elf_got_entry
**) bfd_alloc (abfd
, size
);
2511 if (!local_got_entries
)
2514 memset (local_got_entries
, 0, (size_t) size
);
2515 alpha_elf_tdata (abfd
)->local_got_entries
= local_got_entries
;
2518 slot
= &local_got_entries
[r_symndx
];
2521 for (gotent
= *slot
; gotent
; gotent
= gotent
->next
)
2522 if (gotent
->gotobj
== abfd
2523 && gotent
->reloc_type
== r_type
2524 && gotent
->addend
== r_addend
)
2532 amt
= sizeof (struct alpha_elf_got_entry
);
2533 gotent
= (struct alpha_elf_got_entry
*) bfd_alloc (abfd
, amt
);
2537 gotent
->gotobj
= abfd
;
2538 gotent
->addend
= r_addend
;
2539 gotent
->got_offset
= -1;
2540 gotent
->use_count
= 1;
2541 gotent
->reloc_type
= r_type
;
2542 gotent
->reloc_done
= 0;
2543 gotent
->reloc_xlated
= 0;
2545 gotent
->next
= *slot
;
2548 entry_size
= alpha_got_entry_size (r_type
);
2549 alpha_elf_tdata (abfd
)->total_got_size
+= entry_size
;
2551 alpha_elf_tdata(abfd
)->local_got_size
+= entry_size
;
2554 gotent
->use_count
+= 1;
2559 /* Handle dynamic relocations when doing an Alpha ELF link. */
2562 elf64_alpha_check_relocs (abfd
, info
, sec
, relocs
)
2564 struct bfd_link_info
*info
;
2566 const Elf_Internal_Rela
*relocs
;
2570 const char *rel_sec_name
;
2571 Elf_Internal_Shdr
*symtab_hdr
;
2572 struct alpha_elf_link_hash_entry
**sym_hashes
;
2573 const Elf_Internal_Rela
*rel
, *relend
;
2574 boolean got_created
;
2577 if (info
->relocateable
)
2580 dynobj
= elf_hash_table(info
)->dynobj
;
2582 elf_hash_table(info
)->dynobj
= dynobj
= abfd
;
2585 rel_sec_name
= NULL
;
2586 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2587 sym_hashes
= alpha_elf_sym_hashes(abfd
);
2588 got_created
= false;
2590 relend
= relocs
+ sec
->reloc_count
;
2591 for (rel
= relocs
; rel
< relend
; ++rel
)
2599 unsigned long r_symndx
, r_type
;
2600 struct alpha_elf_link_hash_entry
*h
;
2601 unsigned int gotent_flags
;
2602 boolean maybe_dynamic
;
2606 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2607 if (r_symndx
< symtab_hdr
->sh_info
)
2611 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2613 while (h
->root
.root
.type
== bfd_link_hash_indirect
2614 || h
->root
.root
.type
== bfd_link_hash_warning
)
2615 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2617 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2620 /* We can only get preliminary data on whether a symbol is
2621 locally or externally defined, as not all of the input files
2622 have yet been processed. Do something with what we know, as
2623 this may help reduce memory usage and processing time later. */
2624 maybe_dynamic
= false;
2625 if (h
&& ((info
->shared
2626 && (!info
->symbolic
|| info
->allow_shlib_undefined
))
2627 || ! (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2628 || h
->root
.root
.type
== bfd_link_hash_defweak
))
2629 maybe_dynamic
= true;
2633 r_type
= ELF64_R_TYPE (rel
->r_info
);
2634 addend
= rel
->r_addend
;
2638 case R_ALPHA_LITERAL
:
2639 need
= NEED_GOT
| NEED_GOT_ENTRY
;
2641 /* Remember how this literal is used from its LITUSEs.
2642 This will be important when it comes to decide if we can
2643 create a .plt entry for a function symbol. */
2644 while (++rel
< relend
&& ELF64_R_TYPE (rel
->r_info
) == R_ALPHA_LITUSE
)
2645 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 5)
2646 gotent_flags
|= 1 << rel
->r_addend
;
2649 /* No LITUSEs -- presumably the address is used somehow. */
2650 if (gotent_flags
== 0)
2651 gotent_flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
2654 case R_ALPHA_GPDISP
:
2655 case R_ALPHA_GPREL16
:
2656 case R_ALPHA_GPREL32
:
2657 case R_ALPHA_GPRELHIGH
:
2658 case R_ALPHA_GPRELLOW
:
2663 case R_ALPHA_REFLONG
:
2664 case R_ALPHA_REFQUAD
:
2665 if (info
->shared
|| maybe_dynamic
)
2670 case R_ALPHA_TLSLDM
:
2671 case R_ALPHA_GOTDTPREL
:
2672 need
= NEED_GOT
| NEED_GOT_ENTRY
;
2675 case R_ALPHA_GOTTPREL
:
2676 need
= NEED_GOT
| NEED_GOT_ENTRY
;
2678 info
->flags
|= DF_STATIC_TLS
;
2681 case R_ALPHA_TPREL64
:
2682 if (info
->shared
|| maybe_dynamic
)
2685 info
->flags
|= DF_STATIC_TLS
;
2689 if (need
& NEED_GOT
)
2693 if (!elf64_alpha_create_got_section (abfd
, info
))
2696 /* Make sure the object's gotobj is set to itself so
2697 that we default to every object with its own .got.
2698 We'll merge .gots later once we've collected each
2700 alpha_elf_tdata(abfd
)->gotobj
= abfd
;
2706 if (need
& NEED_GOT_ENTRY
)
2708 struct alpha_elf_got_entry
*gotent
;
2710 gotent
= get_got_entry (abfd
, h
, r_type
, r_symndx
, addend
);
2716 gotent
->flags
|= gotent_flags
;
2719 gotent_flags
|= h
->flags
;
2720 h
->flags
= gotent_flags
;
2722 /* Make a guess as to whether a .plt entry is needed. */
2723 if ((gotent_flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
2724 && !(gotent_flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
))
2725 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2727 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2732 if (need
& NEED_DYNREL
)
2734 if (rel_sec_name
== NULL
)
2736 rel_sec_name
= (bfd_elf_string_from_elf_section
2737 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2738 elf_section_data(sec
)->rel_hdr
.sh_name
));
2739 if (rel_sec_name
== NULL
)
2742 BFD_ASSERT (strncmp (rel_sec_name
, ".rela", 5) == 0
2743 && strcmp (bfd_get_section_name (abfd
, sec
),
2744 rel_sec_name
+5) == 0);
2747 /* We need to create the section here now whether we eventually
2748 use it or not so that it gets mapped to an output section by
2749 the linker. If not used, we'll kill it in
2750 size_dynamic_sections. */
2753 sreloc
= bfd_get_section_by_name (dynobj
, rel_sec_name
);
2758 sreloc
= bfd_make_section (dynobj
, rel_sec_name
);
2759 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2760 | SEC_LINKER_CREATED
| SEC_READONLY
);
2761 if (sec
->flags
& SEC_ALLOC
)
2762 flags
|= SEC_ALLOC
| SEC_LOAD
;
2764 || !bfd_set_section_flags (dynobj
, sreloc
, flags
)
2765 || !bfd_set_section_alignment (dynobj
, sreloc
, 3))
2772 /* Since we havn't seen all of the input symbols yet, we
2773 don't know whether we'll actually need a dynamic relocation
2774 entry for this reloc. So make a record of it. Once we
2775 find out if this thing needs dynamic relocation we'll
2776 expand the relocation sections by the appropriate amount. */
2778 struct alpha_elf_reloc_entry
*rent
;
2780 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
2781 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
2786 amt
= sizeof (struct alpha_elf_reloc_entry
);
2787 rent
= (struct alpha_elf_reloc_entry
*) bfd_alloc (abfd
, amt
);
2791 rent
->srel
= sreloc
;
2792 rent
->rtype
= r_type
;
2794 rent
->reltext
= ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
2795 == (SEC_READONLY
| SEC_ALLOC
));
2797 rent
->next
= h
->reloc_entries
;
2798 h
->reloc_entries
= rent
;
2803 else if (info
->shared
)
2805 /* If this is a shared library, and the section is to be
2806 loaded into memory, we need a RELATIVE reloc. */
2807 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
2808 if ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
2809 == (SEC_READONLY
| SEC_ALLOC
))
2810 info
->flags
|= DF_TEXTREL
;
2818 /* Adjust a symbol defined by a dynamic object and referenced by a
2819 regular object. The current definition is in some section of the
2820 dynamic object, but we're not including those sections. We have to
2821 change the definition to something the rest of the link can
2825 elf64_alpha_adjust_dynamic_symbol (info
, h
)
2826 struct bfd_link_info
*info
;
2827 struct elf_link_hash_entry
*h
;
2831 struct alpha_elf_link_hash_entry
*ah
;
2833 dynobj
= elf_hash_table(info
)->dynobj
;
2834 ah
= (struct alpha_elf_link_hash_entry
*)h
;
2836 /* Now that we've seen all of the input symbols, finalize our decision
2837 about whether this symbol should get a .plt entry. */
2839 if (alpha_elf_dynamic_symbol_p (h
, info
)
2840 && ((h
->type
== STT_FUNC
2841 && !(ah
->flags
& ALPHA_ELF_LINK_HASH_LU_ADDR
))
2842 || (h
->type
== STT_NOTYPE
2843 && (ah
->flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
2844 && !(ah
->flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
)))
2845 /* Don't prevent otherwise valid programs from linking by attempting
2846 to create a new .got entry somewhere. A Correct Solution would be
2847 to add a new .got section to a new object file and let it be merged
2848 somewhere later. But for now don't bother. */
2851 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2853 s
= bfd_get_section_by_name(dynobj
, ".plt");
2854 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
2857 /* The first bit of the .plt is reserved. */
2858 if (s
->_raw_size
== 0)
2859 s
->_raw_size
= PLT_HEADER_SIZE
;
2861 h
->plt
.offset
= s
->_raw_size
;
2862 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2864 /* If this symbol is not defined in a regular file, and we are not
2865 generating a shared library, then set the symbol to the location
2866 in the .plt. This is required to make function pointers compare
2867 equal between the normal executable and the shared library. */
2869 && h
->root
.type
!= bfd_link_hash_defweak
)
2871 h
->root
.u
.def
.section
= s
;
2872 h
->root
.u
.def
.value
= h
->plt
.offset
;
2875 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2876 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2877 BFD_ASSERT (s
!= NULL
);
2878 s
->_raw_size
+= sizeof (Elf64_External_Rela
);
2883 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2885 /* If this is a weak symbol, and there is a real definition, the
2886 processor independent code will have arranged for us to see the
2887 real definition first, and we can just use the same value. */
2888 if (h
->weakdef
!= NULL
)
2890 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2891 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2892 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2893 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2897 /* This is a reference to a symbol defined by a dynamic object which
2898 is not a function. The Alpha, since it uses .got entries for all
2899 symbols even in regular objects, does not need the hackery of a
2900 .dynbss section and COPY dynamic relocations. */
2905 /* Symbol versioning can create new symbols, and make our old symbols
2906 indirect to the new ones. Consolidate the got and reloc information
2907 in these situations. */
2910 elf64_alpha_merge_ind_symbols (hi
, dummy
)
2911 struct alpha_elf_link_hash_entry
*hi
;
2912 PTR dummy ATTRIBUTE_UNUSED
;
2914 struct alpha_elf_link_hash_entry
*hs
;
2916 if (hi
->root
.root
.type
!= bfd_link_hash_indirect
)
2920 hs
= (struct alpha_elf_link_hash_entry
*)hs
->root
.root
.u
.i
.link
;
2921 } while (hs
->root
.root
.type
== bfd_link_hash_indirect
);
2923 /* Merge the flags. Whee. */
2925 hs
->flags
|= hi
->flags
;
2927 /* Merge the .got entries. Cannibalize the old symbol's list in
2928 doing so, since we don't need it anymore. */
2930 if (hs
->got_entries
== NULL
)
2931 hs
->got_entries
= hi
->got_entries
;
2934 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
2936 gsh
= hs
->got_entries
;
2937 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
2940 for (gs
= gsh
; gs
; gs
= gs
->next
)
2941 if (gi
->gotobj
== gs
->gotobj
2942 && gi
->reloc_type
== gs
->reloc_type
2943 && gi
->addend
== gs
->addend
)
2945 gi
->use_count
+= gs
->use_count
;
2948 gi
->next
= hs
->got_entries
;
2949 hs
->got_entries
= gi
;
2953 hi
->got_entries
= NULL
;
2955 /* And similar for the reloc entries. */
2957 if (hs
->reloc_entries
== NULL
)
2958 hs
->reloc_entries
= hi
->reloc_entries
;
2961 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
2963 rsh
= hs
->reloc_entries
;
2964 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
2967 for (rs
= rsh
; rs
; rs
= rs
->next
)
2968 if (ri
->rtype
== rs
->rtype
)
2970 rs
->count
+= ri
->count
;
2973 ri
->next
= hs
->reloc_entries
;
2974 hs
->reloc_entries
= ri
;
2978 hi
->reloc_entries
= NULL
;
2983 /* Is it possible to merge two object file's .got tables? */
2986 elf64_alpha_can_merge_gots (a
, b
)
2989 int total
= alpha_elf_tdata (a
)->total_got_size
;
2992 /* Trivial quick fallout test. */
2993 if (total
+ alpha_elf_tdata (b
)->total_got_size
<= MAX_GOT_SIZE
)
2996 /* By their nature, local .got entries cannot be merged. */
2997 if ((total
+= alpha_elf_tdata (b
)->local_got_size
) > MAX_GOT_SIZE
)
3000 /* Failing the common trivial comparison, we must effectively
3001 perform the merge. Not actually performing the merge means that
3002 we don't have to store undo information in case we fail. */
3003 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3005 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
3006 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3009 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3010 for (i
= 0; i
< n
; ++i
)
3012 struct alpha_elf_got_entry
*ae
, *be
;
3013 struct alpha_elf_link_hash_entry
*h
;
3016 while (h
->root
.root
.type
== bfd_link_hash_indirect
3017 || h
->root
.root
.type
== bfd_link_hash_warning
)
3018 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3020 for (be
= h
->got_entries
; be
; be
= be
->next
)
3022 if (be
->use_count
== 0)
3024 if (be
->gotobj
!= b
)
3027 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
3029 && ae
->reloc_type
== be
->reloc_type
3030 && ae
->addend
== be
->addend
)
3033 total
+= alpha_got_entry_size (be
->reloc_type
);
3034 if (total
> MAX_GOT_SIZE
)
3044 /* Actually merge two .got tables. */
3047 elf64_alpha_merge_gots (a
, b
)
3050 int total
= alpha_elf_tdata (a
)->total_got_size
;
3053 /* Remember local expansion. */
3055 int e
= alpha_elf_tdata (b
)->local_got_size
;
3057 alpha_elf_tdata (a
)->local_got_size
+= e
;
3060 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3062 struct alpha_elf_got_entry
**local_got_entries
;
3063 struct alpha_elf_link_hash_entry
**hashes
;
3064 Elf_Internal_Shdr
*symtab_hdr
;
3067 /* Let the local .got entries know they are part of a new subsegment. */
3068 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
3069 if (local_got_entries
)
3071 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
3072 for (i
= 0; i
< n
; ++i
)
3074 struct alpha_elf_got_entry
*ent
;
3075 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
3080 /* Merge the global .got entries. */
3081 hashes
= alpha_elf_sym_hashes (bsub
);
3082 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3084 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3085 for (i
= 0; i
< n
; ++i
)
3087 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
3088 struct alpha_elf_link_hash_entry
*h
;
3091 while (h
->root
.root
.type
== bfd_link_hash_indirect
3092 || h
->root
.root
.type
== bfd_link_hash_warning
)
3093 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3095 start
= &h
->got_entries
;
3096 for (pbe
= start
, be
= *start
; be
; pbe
= &be
->next
, be
= be
->next
)
3098 if (be
->use_count
== 0)
3103 if (be
->gotobj
!= b
)
3106 for (ae
= *start
; ae
; ae
= ae
->next
)
3108 && ae
->reloc_type
== be
->reloc_type
3109 && ae
->addend
== be
->addend
)
3111 ae
->flags
|= be
->flags
;
3112 ae
->use_count
+= be
->use_count
;
3117 total
+= alpha_got_entry_size (be
->reloc_type
);
3123 alpha_elf_tdata (bsub
)->gotobj
= a
;
3125 alpha_elf_tdata (a
)->total_got_size
= total
;
3127 /* Merge the two in_got chains. */
3132 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
3135 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
3139 /* Calculate the offsets for the got entries. */
3142 elf64_alpha_calc_got_offsets_for_symbol (h
, arg
)
3143 struct alpha_elf_link_hash_entry
*h
;
3144 PTR arg ATTRIBUTE_UNUSED
;
3146 struct alpha_elf_got_entry
*gotent
;
3148 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3149 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3151 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3152 if (gotent
->use_count
> 0)
3155 = &alpha_elf_tdata (gotent
->gotobj
)->got
->_raw_size
;
3157 gotent
->got_offset
= *plge
;
3158 *plge
+= alpha_got_entry_size (gotent
->reloc_type
);
3165 elf64_alpha_calc_got_offsets (info
)
3166 struct bfd_link_info
*info
;
3168 bfd
*i
, *got_list
= alpha_elf_hash_table(info
)->got_list
;
3170 /* First, zero out the .got sizes, as we may be recalculating the
3171 .got after optimizing it. */
3172 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3173 alpha_elf_tdata(i
)->got
->_raw_size
= 0;
3175 /* Next, fill in the offsets for all the global entries. */
3176 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3177 elf64_alpha_calc_got_offsets_for_symbol
,
3180 /* Finally, fill in the offsets for the local entries. */
3181 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3183 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->_raw_size
;
3186 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3188 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3191 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3192 if (!local_got_entries
)
3195 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3196 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
3197 if (gotent
->use_count
> 0)
3199 gotent
->got_offset
= got_offset
;
3200 got_offset
+= alpha_got_entry_size (gotent
->reloc_type
);
3204 alpha_elf_tdata(i
)->got
->_raw_size
= got_offset
;
3205 alpha_elf_tdata(i
)->got
->_cooked_size
= got_offset
;
3209 /* Constructs the gots. */
3212 elf64_alpha_size_got_sections (output_bfd
, info
)
3213 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3214 struct bfd_link_info
*info
;
3216 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
3217 int something_changed
= 0;
3219 got_list
= alpha_elf_hash_table (info
)->got_list
;
3221 /* On the first time through, pretend we have an existing got list
3222 consisting of all of the input files. */
3223 if (got_list
== NULL
)
3225 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
3227 bfd
*this_got
= alpha_elf_tdata (i
)->gotobj
;
3228 if (this_got
== NULL
)
3231 /* We are assuming no merging has yet ocurred. */
3232 BFD_ASSERT (this_got
== i
);
3234 if (alpha_elf_tdata (this_got
)->total_got_size
> MAX_GOT_SIZE
)
3236 /* Yikes! A single object file has too many entries. */
3237 (*_bfd_error_handler
)
3238 (_("%s: .got subsegment exceeds 64K (size %d)"),
3239 bfd_archive_filename (i
),
3240 alpha_elf_tdata (this_got
)->total_got_size
);
3244 if (got_list
== NULL
)
3245 got_list
= this_got
;
3247 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
3248 cur_got_obj
= this_got
;
3251 /* Strange degenerate case of no got references. */
3252 if (got_list
== NULL
)
3255 alpha_elf_hash_table (info
)->got_list
= got_list
;
3257 /* Force got offsets to be recalculated. */
3258 something_changed
= 1;
3261 cur_got_obj
= got_list
;
3262 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
3265 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
3267 elf64_alpha_merge_gots (cur_got_obj
, i
);
3268 i
= alpha_elf_tdata(i
)->got_link_next
;
3269 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
3270 something_changed
= 1;
3275 i
= alpha_elf_tdata(i
)->got_link_next
;
3279 /* Once the gots have been merged, fill in the got offsets for
3280 everything therein. */
3281 if (1 || something_changed
)
3282 elf64_alpha_calc_got_offsets (info
);
3288 elf64_alpha_always_size_sections (output_bfd
, info
)
3290 struct bfd_link_info
*info
;
3294 if (info
->relocateable
)
3297 /* First, take care of the indirect symbols created by versioning. */
3298 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3299 elf64_alpha_merge_ind_symbols
,
3302 if (!elf64_alpha_size_got_sections (output_bfd
, info
))
3305 /* Allocate space for all of the .got subsections. */
3306 i
= alpha_elf_hash_table (info
)->got_list
;
3307 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3309 asection
*s
= alpha_elf_tdata(i
)->got
;
3310 if (s
->_raw_size
> 0)
3312 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->_raw_size
);
3313 if (s
->contents
== NULL
)
3321 /* The number of dynamic relocations required by a static relocation. */
3324 alpha_dynamic_entries_for_reloc (r_type
, dynamic
, shared
)
3325 int r_type
, dynamic
, shared
;
3329 /* May appear in GOT entries. */
3331 return (dynamic
? 2 : shared
? 1 : 0);
3332 case R_ALPHA_TLSLDM
:
3334 case R_ALPHA_LITERAL
:
3335 return dynamic
|| shared
;
3336 case R_ALPHA_GOTDTPREL
:
3337 case R_ALPHA_GOTTPREL
:
3340 /* May appear in data sections. */
3341 case R_ALPHA_REFLONG
:
3342 case R_ALPHA_REFQUAD
:
3343 return dynamic
|| shared
;
3344 case R_ALPHA_SREL64
:
3345 case R_ALPHA_TPREL64
:
3348 /* Everything else is illegal. We'll issue an error during
3349 relocate_section. */
3355 /* Work out the sizes of the dynamic relocation entries. */
3358 elf64_alpha_calc_dynrel_sizes (h
, info
)
3359 struct alpha_elf_link_hash_entry
*h
;
3360 struct bfd_link_info
*info
;
3363 struct alpha_elf_reloc_entry
*relent
;
3364 struct alpha_elf_got_entry
*gotent
;
3367 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3368 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3370 /* If the symbol was defined as a common symbol in a regular object
3371 file, and there was no definition in any dynamic object, then the
3372 linker will have allocated space for the symbol in a common
3373 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3374 set. This is done for dynamic symbols in
3375 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3376 symbols, somehow. */
3377 if (((h
->root
.elf_link_hash_flags
3378 & (ELF_LINK_HASH_DEF_REGULAR
3379 | ELF_LINK_HASH_REF_REGULAR
3380 | ELF_LINK_HASH_DEF_DYNAMIC
))
3381 == ELF_LINK_HASH_REF_REGULAR
)
3382 && (h
->root
.root
.type
== bfd_link_hash_defined
3383 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3384 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3386 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3389 /* If the symbol is dynamic, we'll need all the relocations in their
3390 natural form. If this is a shared object, and it has been forced
3391 local, we'll need the same number of RELATIVE relocations. */
3393 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3395 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
3397 entries
= alpha_dynamic_entries_for_reloc (relent
->rtype
, dynamic
,
3401 relent
->srel
->_raw_size
+=
3402 entries
* sizeof (Elf64_External_Rela
) * relent
->count
;
3403 if (relent
->reltext
)
3404 info
->flags
|= DT_TEXTREL
;
3409 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3410 entries
+= alpha_dynamic_entries_for_reloc (gotent
->reloc_type
,
3411 dynamic
, info
->shared
);
3413 /* If we are using a .plt entry, subtract one, as the first
3414 reference uses a .rela.plt entry instead. */
3415 if (h
->root
.plt
.offset
!= MINUS_ONE
)
3420 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
3421 asection
*srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3422 BFD_ASSERT (srel
!= NULL
);
3423 srel
->_raw_size
+= sizeof (Elf64_External_Rela
) * entries
;
3429 /* Set the sizes of the dynamic sections. */
3432 elf64_alpha_size_dynamic_sections (output_bfd
, info
)
3433 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3434 struct bfd_link_info
*info
;
3440 dynobj
= elf_hash_table(info
)->dynobj
;
3441 BFD_ASSERT(dynobj
!= NULL
);
3443 if (elf_hash_table (info
)->dynamic_sections_created
)
3448 /* Set the contents of the .interp section to the interpreter. */
3451 s
= bfd_get_section_by_name (dynobj
, ".interp");
3452 BFD_ASSERT (s
!= NULL
);
3453 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3454 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3457 /* Now that we've seen all of the input files, we can decide which
3458 symbols need dynamic relocation entries and which don't. We've
3459 collected information in check_relocs that we can now apply to
3460 size the dynamic relocation sections. */
3461 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3462 elf64_alpha_calc_dynrel_sizes
,
3465 /* Shared libraries often require RELATIVE relocs, and some relocs
3466 require attention for the main application as well. */
3469 for (i
= alpha_elf_hash_table(info
)->got_list
;
3470 i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3474 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3476 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3479 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3480 if (!local_got_entries
)
3483 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3484 for (gotent
= local_got_entries
[k
];
3485 gotent
; gotent
= gotent
->next
)
3486 if (gotent
->use_count
> 0)
3487 entries
+= (alpha_dynamic_entries_for_reloc
3488 (gotent
->reloc_type
, 0, info
->shared
));
3494 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
3495 BFD_ASSERT (s
!= NULL
);
3496 s
->_raw_size
+= sizeof (Elf64_External_Rela
) * entries
;
3499 /* else we're not dynamic and by definition we don't need such things. */
3501 /* The check_relocs and adjust_dynamic_symbol entry points have
3502 determined the sizes of the various dynamic sections. Allocate
3505 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3510 if (!(s
->flags
& SEC_LINKER_CREATED
))
3513 /* It's OK to base decisions on the section name, because none
3514 of the dynobj section names depend upon the input files. */
3515 name
= bfd_get_section_name (dynobj
, s
);
3517 /* If we don't need this section, strip it from the output file.
3518 This is to handle .rela.bss and .rela.plt. We must create it
3519 in create_dynamic_sections, because it must be created before
3520 the linker maps input sections to output sections. The
3521 linker does that before adjust_dynamic_symbol is called, and
3522 it is that function which decides whether anything needs to
3523 go into these sections. */
3527 if (strncmp (name
, ".rela", 5) == 0)
3529 strip
= (s
->_raw_size
== 0);
3533 if (strcmp(name
, ".rela.plt") == 0)
3536 /* We use the reloc_count field as a counter if we need
3537 to copy relocs into the output file. */
3541 else if (strcmp (name
, ".plt") != 0)
3543 /* It's not one of our dynamic sections, so don't allocate space. */
3548 _bfd_strip_section_from_output (info
, s
);
3551 /* Allocate memory for the section contents. */
3552 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
3553 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3558 if (elf_hash_table (info
)->dynamic_sections_created
)
3560 /* Add some entries to the .dynamic section. We fill in the
3561 values later, in elf64_alpha_finish_dynamic_sections, but we
3562 must add the entries now so that we get the correct size for
3563 the .dynamic section. The DT_DEBUG entry is filled in by the
3564 dynamic linker and used by the debugger. */
3565 #define add_dynamic_entry(TAG, VAL) \
3566 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3570 if (!add_dynamic_entry (DT_DEBUG
, 0))
3574 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3579 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3580 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3581 || !add_dynamic_entry (DT_JMPREL
, 0))
3585 if (!add_dynamic_entry (DT_RELA
, 0)
3586 || !add_dynamic_entry (DT_RELASZ
, 0)
3587 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
3590 if (info
->flags
& DF_TEXTREL
)
3592 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3596 #undef add_dynamic_entry
3601 /* Relocate an Alpha ELF section. */
3604 elf64_alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3605 contents
, relocs
, local_syms
, local_sections
)
3607 struct bfd_link_info
*info
;
3609 asection
*input_section
;
3611 Elf_Internal_Rela
*relocs
;
3612 Elf_Internal_Sym
*local_syms
;
3613 asection
**local_sections
;
3615 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3616 Elf_Internal_Rela
*rel
;
3617 Elf_Internal_Rela
*relend
;
3618 struct elf_link_tls_segment
*tls_segment
= NULL
;
3619 asection
*sgot
= NULL
, *srel
= NULL
, *srelgot
= NULL
;
3620 bfd
*dynobj
= NULL
, *gotobj
= NULL
;
3621 bfd_vma gp
= 0, tp_base
= 0, dtp_base
= 0;
3622 boolean ret_val
= true;
3624 if (!info
->relocateable
)
3628 dynobj
= elf_hash_table (info
)->dynobj
;
3630 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
3632 name
= (bfd_elf_string_from_elf_section
3633 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
3634 elf_section_data(input_section
)->rel_hdr
.sh_name
));
3635 BFD_ASSERT(name
!= NULL
);
3636 srel
= bfd_get_section_by_name (dynobj
, name
);
3638 /* Find the gp value for this input bfd. */
3639 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
3642 sgot
= alpha_elf_tdata (gotobj
)->got
;
3643 gp
= _bfd_get_gp_value (gotobj
);
3646 gp
= (sgot
->output_section
->vma
3647 + sgot
->output_offset
3649 _bfd_set_gp_value (gotobj
, gp
);
3653 tls_segment
= elf_hash_table (info
)->tls_segment
;
3656 /* This is PT_TLS segment p_vaddr. */
3657 dtp_base
= tls_segment
->start
;
3659 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
3660 is assigned offset round(16, PT_TLS p_align). */
3661 tp_base
= dtp_base
- align_power (16, tls_segment
->align
);
3666 relend
= relocs
+ input_section
->reloc_count
;
3667 for (; rel
< relend
; rel
++)
3669 struct alpha_elf_link_hash_entry
*h
;
3670 struct alpha_elf_got_entry
*gotent
;
3671 bfd_reloc_status_type r
;
3672 reloc_howto_type
*howto
;
3673 unsigned long r_symndx
;
3674 Elf_Internal_Sym
*sym
;
3678 boolean dynamic_symbol_p
;
3679 boolean undef_weak_ref
;
3680 unsigned long r_type
;
3682 r_type
= ELF64_R_TYPE(rel
->r_info
);
3683 if (r_type
>= R_ALPHA_max
)
3685 (*_bfd_error_handler
)
3686 (_("%s: unknown relocation type %d"),
3687 bfd_archive_filename (input_bfd
), (int)r_type
);
3688 bfd_set_error (bfd_error_bad_value
);
3693 howto
= elf64_alpha_howto_table
+ r_type
;
3694 r_symndx
= ELF64_R_SYM(rel
->r_info
);
3696 if (info
->relocateable
)
3698 /* This is a relocateable link. We don't have to change
3699 anything, unless the reloc is against a section symbol,
3700 in which case we have to adjust according to where the
3701 section symbol winds up in the output section. */
3703 /* The symbol associated with GPDISP and LITUSE is
3704 immaterial. Only the addend is significant. */
3705 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
3708 if (r_symndx
< symtab_hdr
->sh_info
)
3710 sym
= local_syms
+ r_symndx
;
3711 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
3713 sec
= local_sections
[r_symndx
];
3714 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
3721 /* This is a final link. */
3726 undef_weak_ref
= false;
3728 if (r_symndx
< symtab_hdr
->sh_info
)
3730 sym
= local_syms
+ r_symndx
;
3731 sec
= local_sections
[r_symndx
];
3732 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
3734 gotent
= alpha_elf_tdata(input_bfd
)->local_got_entries
[r_symndx
];
3736 /* Need to adjust local GOT entries' addends for SEC_MERGE
3737 unless it has been done already. */
3738 if ((sec
->flags
& SEC_MERGE
)
3739 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3740 && (elf_section_data (sec
)->sec_info_type
3741 == ELF_INFO_TYPE_MERGE
)
3742 && !gotent
->reloc_xlated
)
3744 struct alpha_elf_got_entry
*ent
;
3747 for (ent
= gotent
; ent
; ent
= ent
->next
)
3749 ent
->reloc_xlated
= 1;
3750 if (ent
->use_count
== 0)
3754 _bfd_merged_section_offset (output_bfd
, &msec
,
3755 elf_section_data (sec
)->
3757 sym
->st_value
+ ent
->addend
,
3759 ent
->addend
-= sym
->st_value
;
3760 ent
->addend
+= msec
->output_section
->vma
3761 + msec
->output_offset
3762 - sec
->output_section
->vma
3763 - sec
->output_offset
;
3767 dynamic_symbol_p
= false;
3771 h
= alpha_elf_sym_hashes (input_bfd
)[r_symndx
- symtab_hdr
->sh_info
];
3773 while (h
->root
.root
.type
== bfd_link_hash_indirect
3774 || h
->root
.root
.type
== bfd_link_hash_warning
)
3775 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3778 if (h
->root
.root
.type
== bfd_link_hash_defined
3779 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3781 sec
= h
->root
.root
.u
.def
.section
;
3783 /* Detect the cases that sym_sec->output_section is
3784 expected to be NULL -- all cases in which the symbol
3785 is defined in another shared module. This includes
3786 PLT relocs for which we've created a PLT entry and
3787 other relocs for which we're prepared to create
3788 dynamic relocations. */
3789 /* ??? Just accept it NULL and continue. */
3791 if (sec
->output_section
!= NULL
)
3792 value
= (h
->root
.root
.u
.def
.value
3793 + sec
->output_section
->vma
3794 + sec
->output_offset
);
3796 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3797 undef_weak_ref
= true;
3798 else if (info
->shared
3799 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
3800 && !info
->no_undefined
3801 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3805 if (!((*info
->callbacks
->undefined_symbol
)
3806 (info
, h
->root
.root
.root
.string
, input_bfd
,
3807 input_section
, rel
->r_offset
,
3808 (!info
->shared
|| info
->no_undefined
3809 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3815 dynamic_symbol_p
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3816 gotent
= h
->got_entries
;
3819 addend
= rel
->r_addend
;
3822 /* Search for the proper got entry. */
3823 for (; gotent
; gotent
= gotent
->next
)
3824 if (gotent
->gotobj
== gotobj
3825 && gotent
->reloc_type
== r_type
3826 && gotent
->addend
== addend
)
3831 case R_ALPHA_GPDISP
:
3833 bfd_byte
*p_ldah
, *p_lda
;
3835 BFD_ASSERT(gp
!= 0);
3837 value
= (input_section
->output_section
->vma
3838 + input_section
->output_offset
3841 p_ldah
= contents
+ rel
->r_offset
;
3842 p_lda
= p_ldah
+ rel
->r_addend
;
3844 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- value
,
3849 case R_ALPHA_LITERAL
:
3850 BFD_ASSERT(sgot
!= NULL
);
3851 BFD_ASSERT(gp
!= 0);
3852 BFD_ASSERT(gotent
!= NULL
);
3853 BFD_ASSERT(gotent
->use_count
>= 1);
3855 if (!gotent
->reloc_done
)
3857 gotent
->reloc_done
= 1;
3859 bfd_put_64 (output_bfd
, value
,
3860 sgot
->contents
+ gotent
->got_offset
);
3862 /* If the symbol has been forced local, output a
3863 RELATIVE reloc, otherwise it will be handled in
3864 finish_dynamic_symbol. */
3865 if (info
->shared
&& !dynamic_symbol_p
)
3867 Elf_Internal_Rela outrel
;
3869 BFD_ASSERT(srelgot
!= NULL
);
3871 outrel
.r_offset
= (sgot
->output_section
->vma
3872 + sgot
->output_offset
3873 + gotent
->got_offset
);
3874 outrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_RELATIVE
);
3875 outrel
.r_addend
= value
;
3877 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3878 ((Elf64_External_Rela
*)
3880 + srelgot
->reloc_count
++);
3881 BFD_ASSERT (sizeof (Elf64_External_Rela
)
3882 * srelgot
->reloc_count
3883 <= srelgot
->_cooked_size
);
3887 value
= (sgot
->output_section
->vma
3888 + sgot
->output_offset
3889 + gotent
->got_offset
);
3893 case R_ALPHA_GPREL16
:
3894 case R_ALPHA_GPREL32
:
3895 case R_ALPHA_GPRELLOW
:
3896 if (dynamic_symbol_p
)
3898 (*_bfd_error_handler
)
3899 (_("%s: gp-relative relocation against dynamic symbol %s"),
3900 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
3903 BFD_ASSERT(gp
!= 0);
3907 case R_ALPHA_GPRELHIGH
:
3908 if (dynamic_symbol_p
)
3910 (*_bfd_error_handler
)
3911 (_("%s: gp-relative relocation against dynamic symbol %s"),
3912 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
3915 BFD_ASSERT(gp
!= 0);
3917 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
3921 /* A call to a dynamic symbol is definitely out of range of
3922 the 16-bit displacement. Don't bother writing anything. */
3923 if (dynamic_symbol_p
)
3928 /* The regular PC-relative stuff measures from the start of
3929 the instruction rather than the end. */
3933 case R_ALPHA_BRADDR
:
3934 if (dynamic_symbol_p
)
3936 (*_bfd_error_handler
)
3937 (_("%s: pc-relative relocation against dynamic symbol %s"),
3938 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
3941 /* The regular PC-relative stuff measures from the start of
3942 the instruction rather than the end. */
3951 /* The regular PC-relative stuff measures from the start of
3952 the instruction rather than the end. */
3955 /* The source and destination gp must be the same. Note that
3956 the source will always have an assigned gp, since we forced
3957 one in check_relocs, but that the destination may not, as
3958 it might not have had any relocations at all. Also take
3959 care not to crash if H is an undefined symbol. */
3960 if (h
!= NULL
&& sec
!= NULL
3961 && alpha_elf_tdata (sec
->owner
)->gotobj
3962 && gotobj
!= alpha_elf_tdata (sec
->owner
)->gotobj
)
3964 (*_bfd_error_handler
)
3965 (_("%s: change in gp: BRSGP %s"),
3966 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
3970 /* The symbol should be marked either NOPV or STD_GPLOAD. */
3972 other
= h
->root
.other
;
3974 other
= sym
->st_other
;
3975 switch (other
& STO_ALPHA_STD_GPLOAD
)
3977 case STO_ALPHA_NOPV
:
3979 case STO_ALPHA_STD_GPLOAD
:
3984 name
= h
->root
.root
.root
.string
;
3987 name
= (bfd_elf_string_from_elf_section
3988 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
3990 name
= _("<unknown>");
3991 else if (name
[0] == 0)
3992 name
= bfd_section_name (input_bfd
, sec
);
3994 (*_bfd_error_handler
)
3995 (_("%s: !samegp reloc against symbol without .prologue: %s"),
3996 bfd_archive_filename (input_bfd
), name
);
4004 case R_ALPHA_REFLONG
:
4005 case R_ALPHA_REFQUAD
:
4006 case R_ALPHA_DTPREL64
:
4007 case R_ALPHA_TPREL64
:
4009 Elf_Internal_Rela outrel
;
4011 /* Careful here to remember RELATIVE relocations for global
4012 variables for symbolic shared objects. */
4014 if (dynamic_symbol_p
)
4016 BFD_ASSERT(h
->root
.dynindx
!= -1);
4017 outrel
.r_info
= ELF64_R_INFO (h
->root
.dynindx
, r_type
);
4018 outrel
.r_addend
= addend
;
4019 addend
= 0, value
= 0;
4021 else if (r_type
== R_ALPHA_DTPREL64
)
4023 BFD_ASSERT(tls_segment
!= NULL
);
4027 else if (r_type
== R_ALPHA_TPREL64
)
4029 BFD_ASSERT(tls_segment
!= NULL
);
4033 else if (info
->shared
4035 && (input_section
->flags
& SEC_ALLOC
))
4037 if (r_type
== R_ALPHA_REFLONG
)
4039 (*_bfd_error_handler
)
4040 (_("%s: unhandled dynamic relocation against %s"),
4041 bfd_archive_filename (input_bfd
),
4042 h
->root
.root
.root
.string
);
4045 outrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_RELATIVE
);
4046 outrel
.r_addend
= value
;
4051 BFD_ASSERT(srel
!= NULL
);
4054 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4056 if ((outrel
.r_offset
| 1) != (bfd_vma
) -1)
4057 outrel
.r_offset
+= (input_section
->output_section
->vma
4058 + input_section
->output_offset
);
4060 memset (&outrel
, 0, sizeof outrel
);
4062 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4063 ((Elf64_External_Rela
*)
4065 + srel
->reloc_count
++);
4066 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
4067 <= srel
->_cooked_size
);
4071 case R_ALPHA_SREL16
:
4072 case R_ALPHA_SREL32
:
4073 case R_ALPHA_SREL64
:
4074 if (dynamic_symbol_p
)
4076 (*_bfd_error_handler
)
4077 (_("%s: pc-relative relocation against dynamic symbol %s"),
4078 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4082 /* ??? .eh_frame references to discarded sections will be smashed
4083 to relocations against SHN_UNDEF. The .eh_frame format allows
4084 NULL to be encoded as 0 in any format, so this works here. */
4086 howto
= (elf64_alpha_howto_table
4087 + (r_type
- R_ALPHA_SREL32
+ R_ALPHA_REFLONG
));
4090 case R_ALPHA_TLSLDM
:
4091 /* Ignore the symbol for the relocation. The result is always
4092 the current module. */
4093 dynamic_symbol_p
= 0;
4097 if (!gotent
->reloc_done
)
4099 gotent
->reloc_done
= 1;
4101 /* Note that the module index for the main program is 1. */
4102 bfd_put_64 (output_bfd
, !info
->shared
&& !dynamic_symbol_p
,
4103 sgot
->contents
+ gotent
->got_offset
);
4105 /* If the symbol has been forced local, output a
4106 DTPMOD64 reloc, otherwise it will be handled in
4107 finish_dynamic_symbol. */
4108 if (info
->shared
&& !dynamic_symbol_p
)
4110 Elf_Internal_Rela outrel
;
4112 BFD_ASSERT(srelgot
!= NULL
);
4114 outrel
.r_offset
= (sgot
->output_section
->vma
4115 + sgot
->output_offset
4116 + gotent
->got_offset
);
4117 /* ??? Proper dynindx here. */
4118 outrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_DTPMOD64
);
4119 outrel
.r_addend
= 0;
4121 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4122 ((Elf64_External_Rela
*)
4124 + srelgot
->reloc_count
++);
4125 BFD_ASSERT (sizeof (Elf64_External_Rela
)
4126 * srelgot
->reloc_count
4127 <= srelgot
->_cooked_size
);
4130 if (dynamic_symbol_p
|| r_type
== R_ALPHA_TLSLDM
)
4134 BFD_ASSERT(tls_segment
!= NULL
);
4137 bfd_put_64 (output_bfd
, value
,
4138 sgot
->contents
+ gotent
->got_offset
+ 8);
4141 value
= (sgot
->output_section
->vma
4142 + sgot
->output_offset
4143 + gotent
->got_offset
);
4147 case R_ALPHA_DTPRELHI
:
4148 case R_ALPHA_DTPRELLO
:
4149 case R_ALPHA_DTPREL16
:
4150 if (dynamic_symbol_p
)
4152 (*_bfd_error_handler
)
4153 (_("%s: dtp-relative relocation against dynamic symbol %s"),
4154 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4157 BFD_ASSERT(tls_segment
!= NULL
);
4161 case R_ALPHA_TPRELHI
:
4162 case R_ALPHA_TPRELLO
:
4163 case R_ALPHA_TPREL16
:
4164 if (dynamic_symbol_p
)
4166 (*_bfd_error_handler
)
4167 (_("%s: tp-relative relocation against dynamic symbol %s"),
4168 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4171 BFD_ASSERT(tls_segment
!= NULL
);
4175 case R_ALPHA_GOTDTPREL
:
4176 case R_ALPHA_GOTTPREL
:
4177 BFD_ASSERT(sgot
!= NULL
);
4178 BFD_ASSERT(gp
!= 0);
4179 BFD_ASSERT(gotent
!= NULL
);
4180 BFD_ASSERT(gotent
->use_count
>= 1);
4182 if (!gotent
->reloc_done
)
4184 gotent
->reloc_done
= 1;
4186 if (dynamic_symbol_p
)
4190 BFD_ASSERT(tls_segment
!= NULL
);
4191 value
-= (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
4193 bfd_put_64 (output_bfd
, value
,
4194 sgot
->contents
+ gotent
->got_offset
);
4197 value
= (sgot
->output_section
->vma
4198 + sgot
->output_offset
4199 + gotent
->got_offset
);
4205 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4206 contents
, rel
->r_offset
, value
, 0);
4215 case bfd_reloc_overflow
:
4219 /* Don't warn if the overflow is due to pc relative reloc
4220 against discarded section. Section optimization code should
4223 if (r_symndx
< symtab_hdr
->sh_info
4224 && sec
!= NULL
&& howto
->pc_relative
4225 && elf_discarded_section (sec
))
4229 name
= h
->root
.root
.root
.string
;
4232 name
= (bfd_elf_string_from_elf_section
4233 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4237 name
= bfd_section_name (input_bfd
, sec
);
4239 if (! ((*info
->callbacks
->reloc_overflow
)
4240 (info
, name
, howto
->name
, (bfd_vma
) 0,
4241 input_bfd
, input_section
, rel
->r_offset
)))
4247 case bfd_reloc_outofrange
:
4255 /* Finish up dynamic symbol handling. We set the contents of various
4256 dynamic sections here. */
4259 elf64_alpha_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4261 struct bfd_link_info
*info
;
4262 struct elf_link_hash_entry
*h
;
4263 Elf_Internal_Sym
*sym
;
4265 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
4267 if (h
->plt
.offset
!= MINUS_ONE
)
4269 /* Fill in the .plt entry for this symbol. */
4270 asection
*splt
, *sgot
, *srel
;
4271 Elf_Internal_Rela outrel
;
4272 bfd_vma got_addr
, plt_addr
;
4274 struct alpha_elf_got_entry
*gotent
;
4276 BFD_ASSERT (h
->dynindx
!= -1);
4278 /* The first .got entry will be updated by the .plt with the
4279 address of the target function. */
4280 gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4281 BFD_ASSERT (gotent
&& gotent
->addend
== 0);
4283 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4284 BFD_ASSERT (splt
!= NULL
);
4285 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4286 BFD_ASSERT (srel
!= NULL
);
4287 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4288 BFD_ASSERT (sgot
!= NULL
);
4290 got_addr
= (sgot
->output_section
->vma
4291 + sgot
->output_offset
4292 + gotent
->got_offset
);
4293 plt_addr
= (splt
->output_section
->vma
4294 + splt
->output_offset
4297 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
4299 /* Fill in the entry in the procedure linkage table. */
4301 bfd_vma insn1
, insn2
, insn3
;
4303 insn1
= PLT_ENTRY_WORD1
| ((-(h
->plt
.offset
+ 4) >> 2) & 0x1fffff);
4304 insn2
= PLT_ENTRY_WORD2
;
4305 insn3
= PLT_ENTRY_WORD3
;
4307 bfd_put_32 (output_bfd
, insn1
, splt
->contents
+ h
->plt
.offset
);
4308 bfd_put_32 (output_bfd
, insn2
, splt
->contents
+ h
->plt
.offset
+ 4);
4309 bfd_put_32 (output_bfd
, insn3
, splt
->contents
+ h
->plt
.offset
+ 8);
4312 /* Fill in the entry in the .rela.plt section. */
4313 outrel
.r_offset
= got_addr
;
4314 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
4315 outrel
.r_addend
= 0;
4317 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4318 ((Elf64_External_Rela
*)srel
->contents
4321 if (!(h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
4323 /* Mark the symbol as undefined, rather than as defined in the
4324 .plt section. Leave the value alone. */
4325 sym
->st_shndx
= SHN_UNDEF
;
4328 /* Fill in the entries in the .got. */
4329 bfd_put_64 (output_bfd
, plt_addr
, sgot
->contents
+ gotent
->got_offset
);
4331 /* Subsequent .got entries will continue to bounce through the .plt. */
4334 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4335 BFD_ASSERT (! info
->shared
|| srel
!= NULL
);
4337 gotent
= gotent
->next
;
4340 sgot
= alpha_elf_tdata(gotent
->gotobj
)->got
;
4341 BFD_ASSERT(sgot
!= NULL
);
4342 BFD_ASSERT(gotent
->addend
== 0);
4344 bfd_put_64 (output_bfd
, plt_addr
,
4345 sgot
->contents
+ gotent
->got_offset
);
4349 outrel
.r_offset
= (sgot
->output_section
->vma
4350 + sgot
->output_offset
4351 + gotent
->got_offset
);
4352 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
4353 outrel
.r_addend
= plt_addr
;
4355 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4356 ((Elf64_External_Rela
*)
4358 + srel
->reloc_count
++);
4359 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
4360 <= srel
->_cooked_size
);
4363 gotent
= gotent
->next
;
4365 while (gotent
!= NULL
);
4368 else if (alpha_elf_dynamic_symbol_p (h
, info
))
4370 /* Fill in the dynamic relocations for this symbol's .got entries. */
4372 Elf_Internal_Rela outrel
;
4373 struct alpha_elf_got_entry
*gotent
;
4375 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4376 BFD_ASSERT (srel
!= NULL
);
4378 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4380 gotent
= gotent
->next
)
4382 asection
*sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4385 outrel
.r_offset
= (sgot
->output_section
->vma
4386 + sgot
->output_offset
4387 + gotent
->got_offset
);
4389 r_type
= gotent
->reloc_type
;
4392 case R_ALPHA_LITERAL
:
4393 r_type
= R_ALPHA_GLOB_DAT
;
4396 r_type
= R_ALPHA_DTPMOD64
;
4398 case R_ALPHA_GOTDTPREL
:
4399 r_type
= R_ALPHA_DTPREL64
;
4401 case R_ALPHA_GOTTPREL
:
4402 r_type
= R_ALPHA_TPREL64
;
4404 case R_ALPHA_TLSLDM
:
4409 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
4410 outrel
.r_addend
= gotent
->addend
;
4412 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4413 ((Elf64_External_Rela
*)srel
->contents
4414 + srel
->reloc_count
++));
4416 if (gotent
->reloc_type
== R_ALPHA_TLSGD
)
4418 outrel
.r_offset
+= 8;
4419 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_ALPHA_DTPREL64
);
4421 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4422 ((Elf64_External_Rela
*)srel
->contents
4423 + srel
->reloc_count
++));
4426 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
4427 <= srel
->_cooked_size
);
4431 /* Mark some specially defined symbols as absolute. */
4432 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4433 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
4434 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4435 sym
->st_shndx
= SHN_ABS
;
4440 /* Finish up the dynamic sections. */
4443 elf64_alpha_finish_dynamic_sections (output_bfd
, info
)
4445 struct bfd_link_info
*info
;
4450 dynobj
= elf_hash_table (info
)->dynobj
;
4451 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4453 if (elf_hash_table (info
)->dynamic_sections_created
)
4456 Elf64_External_Dyn
*dyncon
, *dynconend
;
4458 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4459 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4461 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
4462 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4463 for (; dyncon
< dynconend
; dyncon
++)
4465 Elf_Internal_Dyn dyn
;
4469 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4484 /* My interpretation of the TIS v1.1 ELF document indicates
4485 that RELASZ should not include JMPREL. This is not what
4486 the rest of the BFD does. It is, however, what the
4487 glibc ld.so wants. Do this fixup here until we found
4488 out who is right. */
4489 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
4493 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
4498 s
= bfd_get_section_by_name (output_bfd
, name
);
4499 dyn
.d_un
.d_ptr
= (s
? s
->vma
: 0);
4503 s
= bfd_get_section_by_name (output_bfd
, name
);
4505 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
4509 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4512 /* Initialize the PLT0 entry */
4513 if (splt
->_raw_size
> 0)
4515 bfd_put_32 (output_bfd
, PLT_HEADER_WORD1
, splt
->contents
);
4516 bfd_put_32 (output_bfd
, PLT_HEADER_WORD2
, splt
->contents
+ 4);
4517 bfd_put_32 (output_bfd
, PLT_HEADER_WORD3
, splt
->contents
+ 8);
4518 bfd_put_32 (output_bfd
, PLT_HEADER_WORD4
, splt
->contents
+ 12);
4520 /* The next two words will be filled in by ld.so */
4521 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 16);
4522 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 24);
4524 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
4532 /* We need to use a special link routine to handle the .mdebug section.
4533 We need to merge all instances of these sections together, not write
4534 them all out sequentially. */
4537 elf64_alpha_final_link (abfd
, info
)
4539 struct bfd_link_info
*info
;
4542 struct bfd_link_order
*p
;
4543 asection
*mdebug_sec
;
4544 struct ecoff_debug_info debug
;
4545 const struct ecoff_debug_swap
*swap
4546 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
4547 HDRR
*symhdr
= &debug
.symbolic_header
;
4548 PTR mdebug_handle
= NULL
;
4550 /* Go through the sections and collect the mdebug information. */
4552 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4554 if (strcmp (o
->name
, ".mdebug") == 0)
4556 struct extsym_info einfo
;
4558 /* We have found the .mdebug section in the output file.
4559 Look through all the link_orders comprising it and merge
4560 the information together. */
4561 symhdr
->magic
= swap
->sym_magic
;
4562 /* FIXME: What should the version stamp be? */
4564 symhdr
->ilineMax
= 0;
4568 symhdr
->isymMax
= 0;
4569 symhdr
->ioptMax
= 0;
4570 symhdr
->iauxMax
= 0;
4572 symhdr
->issExtMax
= 0;
4575 symhdr
->iextMax
= 0;
4577 /* We accumulate the debugging information itself in the
4578 debug_info structure. */
4580 debug
.external_dnr
= NULL
;
4581 debug
.external_pdr
= NULL
;
4582 debug
.external_sym
= NULL
;
4583 debug
.external_opt
= NULL
;
4584 debug
.external_aux
= NULL
;
4586 debug
.ssext
= debug
.ssext_end
= NULL
;
4587 debug
.external_fdr
= NULL
;
4588 debug
.external_rfd
= NULL
;
4589 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4591 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4592 if (mdebug_handle
== (PTR
) NULL
)
4601 static const char * const name
[] =
4603 ".text", ".init", ".fini", ".data",
4604 ".rodata", ".sdata", ".sbss", ".bss"
4606 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
4607 scRData
, scSData
, scSBss
, scBss
};
4610 esym
.cobol_main
= 0;
4614 esym
.asym
.iss
= issNil
;
4615 esym
.asym
.st
= stLocal
;
4616 esym
.asym
.reserved
= 0;
4617 esym
.asym
.index
= indexNil
;
4618 for (i
= 0; i
< 8; i
++)
4620 esym
.asym
.sc
= sc
[i
];
4621 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4624 esym
.asym
.value
= s
->vma
;
4625 last
= s
->vma
+ s
->_raw_size
;
4628 esym
.asym
.value
= last
;
4630 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4636 for (p
= o
->link_order_head
;
4637 p
!= (struct bfd_link_order
*) NULL
;
4640 asection
*input_section
;
4642 const struct ecoff_debug_swap
*input_swap
;
4643 struct ecoff_debug_info input_debug
;
4647 if (p
->type
!= bfd_indirect_link_order
)
4649 if (p
->type
== bfd_data_link_order
)
4654 input_section
= p
->u
.indirect
.section
;
4655 input_bfd
= input_section
->owner
;
4657 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4658 || (get_elf_backend_data (input_bfd
)
4659 ->elf_backend_ecoff_debug_swap
) == NULL
)
4661 /* I don't know what a non ALPHA ELF bfd would be
4662 doing with a .mdebug section, but I don't really
4663 want to deal with it. */
4667 input_swap
= (get_elf_backend_data (input_bfd
)
4668 ->elf_backend_ecoff_debug_swap
);
4670 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4672 /* The ECOFF linking code expects that we have already
4673 read in the debugging information and set up an
4674 ecoff_debug_info structure, so we do that now. */
4675 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
4679 if (! (bfd_ecoff_debug_accumulate
4680 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4681 &input_debug
, input_swap
, info
)))
4684 /* Loop through the external symbols. For each one with
4685 interesting information, try to find the symbol in
4686 the linker global hash table and save the information
4687 for the output external symbols. */
4688 eraw_src
= input_debug
.external_ext
;
4689 eraw_end
= (eraw_src
4690 + (input_debug
.symbolic_header
.iextMax
4691 * input_swap
->external_ext_size
));
4693 eraw_src
< eraw_end
;
4694 eraw_src
+= input_swap
->external_ext_size
)
4698 struct alpha_elf_link_hash_entry
*h
;
4700 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4701 if (ext
.asym
.sc
== scNil
4702 || ext
.asym
.sc
== scUndefined
4703 || ext
.asym
.sc
== scSUndefined
)
4706 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4707 h
= alpha_elf_link_hash_lookup (alpha_elf_hash_table (info
),
4708 name
, false, false, true);
4709 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4715 < input_debug
.symbolic_header
.ifdMax
);
4716 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4722 /* Free up the information we just read. */
4723 free (input_debug
.line
);
4724 free (input_debug
.external_dnr
);
4725 free (input_debug
.external_pdr
);
4726 free (input_debug
.external_sym
);
4727 free (input_debug
.external_opt
);
4728 free (input_debug
.external_aux
);
4729 free (input_debug
.ss
);
4730 free (input_debug
.ssext
);
4731 free (input_debug
.external_fdr
);
4732 free (input_debug
.external_rfd
);
4733 free (input_debug
.external_ext
);
4735 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4736 elf_link_input_bfd ignores this section. */
4737 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4740 /* Build the external symbol information. */
4743 einfo
.debug
= &debug
;
4745 einfo
.failed
= false;
4746 elf_link_hash_traverse (elf_hash_table (info
),
4747 elf64_alpha_output_extsym
,
4752 /* Set the size of the .mdebug section. */
4753 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4755 /* Skip this section later on (I don't think this currently
4756 matters, but someday it might). */
4757 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4763 /* Invoke the regular ELF backend linker to do all the work. */
4764 if (! bfd_elf64_bfd_final_link (abfd
, info
))
4767 /* Now write out the computed sections. */
4769 /* The .got subsections... */
4771 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
4772 for (i
= alpha_elf_hash_table(info
)->got_list
;
4774 i
= alpha_elf_tdata(i
)->got_link_next
)
4778 /* elf_bfd_final_link already did everything in dynobj. */
4782 sgot
= alpha_elf_tdata(i
)->got
;
4783 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
4785 (file_ptr
) sgot
->output_offset
,
4791 if (mdebug_sec
!= (asection
*) NULL
)
4793 BFD_ASSERT (abfd
->output_has_begun
);
4794 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
4796 mdebug_sec
->filepos
))
4799 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
4805 static enum elf_reloc_type_class
4806 elf64_alpha_reloc_type_class (rela
)
4807 const Elf_Internal_Rela
*rela
;
4809 switch ((int) ELF64_R_TYPE (rela
->r_info
))
4811 case R_ALPHA_RELATIVE
:
4812 return reloc_class_relative
;
4813 case R_ALPHA_JMP_SLOT
:
4814 return reloc_class_plt
;
4816 return reloc_class_copy
;
4818 return reloc_class_normal
;
4822 /* ECOFF swapping routines. These are used when dealing with the
4823 .mdebug section, which is in the ECOFF debugging format. Copied
4824 from elf32-mips.c. */
4825 static const struct ecoff_debug_swap
4826 elf64_alpha_ecoff_debug_swap
=
4828 /* Symbol table magic number. */
4830 /* Alignment of debugging information. E.g., 4. */
4832 /* Sizes of external symbolic information. */
4833 sizeof (struct hdr_ext
),
4834 sizeof (struct dnr_ext
),
4835 sizeof (struct pdr_ext
),
4836 sizeof (struct sym_ext
),
4837 sizeof (struct opt_ext
),
4838 sizeof (struct fdr_ext
),
4839 sizeof (struct rfd_ext
),
4840 sizeof (struct ext_ext
),
4841 /* Functions to swap in external symbolic data. */
4850 _bfd_ecoff_swap_tir_in
,
4851 _bfd_ecoff_swap_rndx_in
,
4852 /* Functions to swap out external symbolic data. */
4861 _bfd_ecoff_swap_tir_out
,
4862 _bfd_ecoff_swap_rndx_out
,
4863 /* Function to read in symbolic data. */
4864 elf64_alpha_read_ecoff_info
4867 /* Use a non-standard hash bucket size of 8. */
4869 const struct elf_size_info alpha_elf_size_info
=
4871 sizeof (Elf64_External_Ehdr
),
4872 sizeof (Elf64_External_Phdr
),
4873 sizeof (Elf64_External_Shdr
),
4874 sizeof (Elf64_External_Rel
),
4875 sizeof (Elf64_External_Rela
),
4876 sizeof (Elf64_External_Sym
),
4877 sizeof (Elf64_External_Dyn
),
4878 sizeof (Elf_External_Note
),
4882 ELFCLASS64
, EV_CURRENT
,
4883 bfd_elf64_write_out_phdrs
,
4884 bfd_elf64_write_shdrs_and_ehdr
,
4885 bfd_elf64_write_relocs
,
4886 bfd_elf64_swap_symbol_out
,
4887 bfd_elf64_slurp_reloc_table
,
4888 bfd_elf64_slurp_symbol_table
,
4889 bfd_elf64_swap_dyn_in
,
4890 bfd_elf64_swap_dyn_out
,
4897 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4898 #define TARGET_LITTLE_NAME "elf64-alpha"
4899 #define ELF_ARCH bfd_arch_alpha
4900 #define ELF_MACHINE_CODE EM_ALPHA
4901 #define ELF_MAXPAGESIZE 0x10000
4903 #define bfd_elf64_bfd_link_hash_table_create \
4904 elf64_alpha_bfd_link_hash_table_create
4906 #define bfd_elf64_bfd_reloc_type_lookup \
4907 elf64_alpha_bfd_reloc_type_lookup
4908 #define elf_info_to_howto \
4909 elf64_alpha_info_to_howto
4911 #define bfd_elf64_mkobject \
4912 elf64_alpha_mkobject
4913 #define elf_backend_object_p \
4914 elf64_alpha_object_p
4916 #define elf_backend_section_from_shdr \
4917 elf64_alpha_section_from_shdr
4918 #define elf_backend_section_flags \
4919 elf64_alpha_section_flags
4920 #define elf_backend_fake_sections \
4921 elf64_alpha_fake_sections
4923 #define bfd_elf64_bfd_is_local_label_name \
4924 elf64_alpha_is_local_label_name
4925 #define bfd_elf64_find_nearest_line \
4926 elf64_alpha_find_nearest_line
4927 #define bfd_elf64_bfd_relax_section \
4928 elf64_alpha_relax_section
4930 #define elf_backend_add_symbol_hook \
4931 elf64_alpha_add_symbol_hook
4932 #define elf_backend_check_relocs \
4933 elf64_alpha_check_relocs
4934 #define elf_backend_create_dynamic_sections \
4935 elf64_alpha_create_dynamic_sections
4936 #define elf_backend_adjust_dynamic_symbol \
4937 elf64_alpha_adjust_dynamic_symbol
4938 #define elf_backend_always_size_sections \
4939 elf64_alpha_always_size_sections
4940 #define elf_backend_size_dynamic_sections \
4941 elf64_alpha_size_dynamic_sections
4942 #define elf_backend_relocate_section \
4943 elf64_alpha_relocate_section
4944 #define elf_backend_finish_dynamic_symbol \
4945 elf64_alpha_finish_dynamic_symbol
4946 #define elf_backend_finish_dynamic_sections \
4947 elf64_alpha_finish_dynamic_sections
4948 #define bfd_elf64_bfd_final_link \
4949 elf64_alpha_final_link
4950 #define elf_backend_reloc_type_class \
4951 elf64_alpha_reloc_type_class
4953 #define elf_backend_ecoff_debug_swap \
4954 &elf64_alpha_ecoff_debug_swap
4956 #define elf_backend_size_info \
4959 /* A few constants that determine how the .plt section is set up. */
4960 #define elf_backend_want_got_plt 0
4961 #define elf_backend_plt_readonly 0
4962 #define elf_backend_want_plt_sym 1
4963 #define elf_backend_got_header_size 0
4964 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4966 #include "elf64-target.h"