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
*, const 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 ((struct bfd_link_info
*));
110 static boolean elf64_alpha_size_plt_section
111 PARAMS ((struct bfd_link_info
*));
112 static boolean elf64_alpha_size_plt_section_1
113 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
114 static boolean elf64_alpha_always_size_sections
115 PARAMS ((bfd
*, struct bfd_link_info
*));
116 static int alpha_dynamic_entries_for_reloc
117 PARAMS ((int, int, int));
118 static boolean elf64_alpha_calc_dynrel_sizes
119 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
120 static boolean elf64_alpha_size_rela_got_section
121 PARAMS ((struct bfd_link_info
*));
122 static boolean elf64_alpha_size_rela_got_1
123 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
124 static boolean elf64_alpha_add_symbol_hook
125 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
126 const char **, flagword
*, asection
**, bfd_vma
*));
127 static struct alpha_elf_got_entry
*get_got_entry
128 PARAMS ((bfd
*, struct alpha_elf_link_hash_entry
*, unsigned long,
129 unsigned long, bfd_vma
));
130 static boolean elf64_alpha_check_relocs
131 PARAMS((bfd
*, struct bfd_link_info
*, asection
*sec
,
132 const Elf_Internal_Rela
*));
133 static boolean elf64_alpha_adjust_dynamic_symbol
134 PARAMS((struct bfd_link_info
*, struct elf_link_hash_entry
*));
135 static boolean elf64_alpha_size_dynamic_sections
136 PARAMS((bfd
*, struct bfd_link_info
*));
137 static boolean elf64_alpha_relocate_section_r
138 PARAMS((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
139 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
140 static boolean elf64_alpha_relocate_section
141 PARAMS((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
142 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
143 static boolean elf64_alpha_finish_dynamic_symbol
144 PARAMS((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
145 Elf_Internal_Sym
*));
146 static boolean elf64_alpha_finish_dynamic_sections
147 PARAMS((bfd
*, struct bfd_link_info
*));
148 static boolean elf64_alpha_final_link
149 PARAMS((bfd
*, struct bfd_link_info
*));
150 static boolean elf64_alpha_merge_ind_symbols
151 PARAMS((struct alpha_elf_link_hash_entry
*, PTR
));
152 static Elf_Internal_Rela
* elf64_alpha_find_reloc_at_ofs
153 PARAMS ((Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_vma
, int));
154 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
155 PARAMS ((const Elf_Internal_Rela
*));
157 struct alpha_elf_link_hash_entry
159 struct elf_link_hash_entry root
;
161 /* External symbol information. */
164 /* Cumulative flags for all the .got entries. */
167 /* Contexts in which a literal was referenced. */
168 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
169 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
170 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
171 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
172 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
173 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
174 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x38
175 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x40
177 /* Used to implement multiple .got subsections. */
178 struct alpha_elf_got_entry
180 struct alpha_elf_got_entry
*next
;
182 /* which .got subsection? */
185 /* the addend in effect for this entry. */
188 /* the .got offset for this entry. */
191 /* How many references to this entry? */
194 /* The relocation type of this entry. */
195 unsigned char reloc_type
;
197 /* How a LITERAL is used. */
200 /* Have we initialized the dynamic relocation for this entry? */
201 unsigned char reloc_done
;
203 /* Have we adjusted this entry for SEC_MERGE? */
204 unsigned char reloc_xlated
;
207 /* used to count non-got, non-plt relocations for delayed sizing
208 of relocation sections. */
209 struct alpha_elf_reloc_entry
211 struct alpha_elf_reloc_entry
*next
;
213 /* which .reloc section? */
216 /* what kind of relocation? */
219 /* is this against read-only section? */
220 unsigned int reltext
: 1;
222 /* how many did we find? */
227 /* Alpha ELF linker hash table. */
229 struct alpha_elf_link_hash_table
231 struct elf_link_hash_table root
;
233 /* The head of a list of .got subsections linked through
234 alpha_elf_tdata(abfd)->got_link_next. */
238 /* Look up an entry in a Alpha ELF linker hash table. */
240 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
241 ((struct alpha_elf_link_hash_entry *) \
242 elf_link_hash_lookup (&(table)->root, (string), (create), \
245 /* Traverse a Alpha ELF linker hash table. */
247 #define alpha_elf_link_hash_traverse(table, func, info) \
248 (elf_link_hash_traverse \
250 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
253 /* Get the Alpha ELF linker hash table from a link_info structure. */
255 #define alpha_elf_hash_table(p) \
256 ((struct alpha_elf_link_hash_table *) ((p)->hash))
258 /* Get the object's symbols as our own entry type. */
260 #define alpha_elf_sym_hashes(abfd) \
261 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
263 /* Should we do dynamic things to this symbol? */
266 alpha_elf_dynamic_symbol_p (h
, info
)
267 struct elf_link_hash_entry
*h
;
268 struct bfd_link_info
*info
;
273 while (h
->root
.type
== bfd_link_hash_indirect
274 || h
->root
.type
== bfd_link_hash_warning
)
275 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
277 if (h
->dynindx
== -1)
280 if (h
->root
.type
== bfd_link_hash_undefweak
281 || h
->root
.type
== bfd_link_hash_defweak
)
284 switch (ELF_ST_VISIBILITY (h
->other
))
292 if (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
297 if ((info
->shared
&& !info
->symbolic
)
298 || ((h
->elf_link_hash_flags
299 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
300 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
306 /* Create an entry in a Alpha ELF linker hash table. */
308 static struct bfd_hash_entry
*
309 elf64_alpha_link_hash_newfunc (entry
, table
, string
)
310 struct bfd_hash_entry
*entry
;
311 struct bfd_hash_table
*table
;
314 struct alpha_elf_link_hash_entry
*ret
=
315 (struct alpha_elf_link_hash_entry
*) entry
;
317 /* Allocate the structure if it has not already been allocated by a
319 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
320 ret
= ((struct alpha_elf_link_hash_entry
*)
321 bfd_hash_allocate (table
,
322 sizeof (struct alpha_elf_link_hash_entry
)));
323 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
324 return (struct bfd_hash_entry
*) ret
;
326 /* Call the allocation method of the superclass. */
327 ret
= ((struct alpha_elf_link_hash_entry
*)
328 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
330 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
332 /* Set local fields. */
333 memset (&ret
->esym
, 0, sizeof (EXTR
));
334 /* We use -2 as a marker to indicate that the information has
335 not been set. -1 means there is no associated ifd. */
338 ret
->got_entries
= NULL
;
339 ret
->reloc_entries
= NULL
;
342 return (struct bfd_hash_entry
*) ret
;
345 /* Create a Alpha ELF linker hash table. */
347 static struct bfd_link_hash_table
*
348 elf64_alpha_bfd_link_hash_table_create (abfd
)
351 struct alpha_elf_link_hash_table
*ret
;
352 bfd_size_type amt
= sizeof (struct alpha_elf_link_hash_table
);
354 ret
= (struct alpha_elf_link_hash_table
*) bfd_zmalloc (amt
);
355 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
358 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
359 elf64_alpha_link_hash_newfunc
))
365 return &ret
->root
.root
;
368 /* We have some private fields hanging off of the elf_tdata structure. */
370 struct alpha_elf_obj_tdata
372 struct elf_obj_tdata root
;
374 /* For every input file, these are the got entries for that object's
376 struct alpha_elf_got_entry
** local_got_entries
;
378 /* For every input file, this is the object that owns the got that
379 this input file uses. */
382 /* For every got, this is a linked list through the objects using this got */
383 bfd
*in_got_link_next
;
385 /* For every got, this is a link to the next got subsegment. */
388 /* For every got, this is the section. */
391 /* For every got, this is it's total number of words. */
394 /* For every got, this is the sum of the number of words required
395 to hold all of the member object's local got. */
399 #define alpha_elf_tdata(abfd) \
400 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
403 elf64_alpha_mkobject (abfd
)
406 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
407 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
408 if (abfd
->tdata
.any
== NULL
)
414 elf64_alpha_object_p (abfd
)
417 /* Allocate our special target data. */
418 struct alpha_elf_obj_tdata
*new_tdata
;
419 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
420 new_tdata
= bfd_zalloc (abfd
, amt
);
421 if (new_tdata
== NULL
)
423 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
424 abfd
->tdata
.any
= new_tdata
;
426 /* Set the right machine number for an Alpha ELF file. */
427 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
430 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
431 from smaller values. Start with zero, widen, *then* decrement. */
432 #define MINUS_ONE (((bfd_vma)0) - 1)
434 #define SKIP_HOWTO(N) \
435 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
437 static reloc_howto_type elf64_alpha_howto_table
[] =
439 HOWTO (R_ALPHA_NONE
, /* type */
441 0, /* size (0 = byte, 1 = short, 2 = long) */
443 true, /* pc_relative */
445 complain_overflow_dont
, /* complain_on_overflow */
446 elf64_alpha_reloc_nil
, /* special_function */
448 false, /* partial_inplace */
451 true), /* pcrel_offset */
453 /* A 32 bit reference to a symbol. */
454 HOWTO (R_ALPHA_REFLONG
, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 false, /* pc_relative */
460 complain_overflow_bitfield
, /* complain_on_overflow */
461 0, /* special_function */
462 "REFLONG", /* name */
463 false, /* partial_inplace */
464 0xffffffff, /* src_mask */
465 0xffffffff, /* dst_mask */
466 false), /* pcrel_offset */
468 /* A 64 bit reference to a symbol. */
469 HOWTO (R_ALPHA_REFQUAD
, /* type */
471 4, /* size (0 = byte, 1 = short, 2 = long) */
473 false, /* pc_relative */
475 complain_overflow_bitfield
, /* complain_on_overflow */
476 0, /* special_function */
477 "REFQUAD", /* name */
478 false, /* partial_inplace */
479 MINUS_ONE
, /* src_mask */
480 MINUS_ONE
, /* dst_mask */
481 false), /* pcrel_offset */
483 /* A 32 bit GP relative offset. This is just like REFLONG except
484 that when the value is used the value of the gp register will be
486 HOWTO (R_ALPHA_GPREL32
, /* type */
488 2, /* size (0 = byte, 1 = short, 2 = long) */
490 false, /* pc_relative */
492 complain_overflow_bitfield
, /* complain_on_overflow */
493 0, /* special_function */
494 "GPREL32", /* name */
495 false, /* partial_inplace */
496 0xffffffff, /* src_mask */
497 0xffffffff, /* dst_mask */
498 false), /* pcrel_offset */
500 /* Used for an instruction that refers to memory off the GP register. */
501 HOWTO (R_ALPHA_LITERAL
, /* type */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
505 false, /* pc_relative */
507 complain_overflow_signed
, /* complain_on_overflow */
508 0, /* special_function */
509 "ELF_LITERAL", /* name */
510 false, /* partial_inplace */
511 0xffff, /* src_mask */
512 0xffff, /* dst_mask */
513 false), /* pcrel_offset */
515 /* This reloc only appears immediately following an ELF_LITERAL reloc.
516 It identifies a use of the literal. The symbol index is special:
517 1 means the literal address is in the base register of a memory
518 format instruction; 2 means the literal address is in the byte
519 offset register of a byte-manipulation instruction; 3 means the
520 literal address is in the target register of a jsr instruction.
521 This does not actually do any relocation. */
522 HOWTO (R_ALPHA_LITUSE
, /* type */
524 1, /* size (0 = byte, 1 = short, 2 = long) */
526 false, /* pc_relative */
528 complain_overflow_dont
, /* complain_on_overflow */
529 elf64_alpha_reloc_nil
, /* special_function */
531 false, /* partial_inplace */
534 false), /* pcrel_offset */
536 /* Load the gp register. This is always used for a ldah instruction
537 which loads the upper 16 bits of the gp register. The symbol
538 index of the GPDISP instruction is an offset in bytes to the lda
539 instruction that loads the lower 16 bits. The value to use for
540 the relocation is the difference between the GP value and the
541 current location; the load will always be done against a register
542 holding the current address.
544 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
545 any offset is present in the instructions, it is an offset from
546 the register to the ldah instruction. This lets us avoid any
547 stupid hackery like inventing a gp value to do partial relocation
548 against. Also unlike ECOFF, we do the whole relocation off of
549 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
550 space consuming bit, that, since all the information was present
551 in the GPDISP_HI16 reloc. */
552 HOWTO (R_ALPHA_GPDISP
, /* type */
554 2, /* size (0 = byte, 1 = short, 2 = long) */
556 false, /* pc_relative */
558 complain_overflow_dont
, /* complain_on_overflow */
559 elf64_alpha_reloc_gpdisp
, /* special_function */
561 false, /* partial_inplace */
562 0xffff, /* src_mask */
563 0xffff, /* dst_mask */
564 true), /* pcrel_offset */
566 /* A 21 bit branch. */
567 HOWTO (R_ALPHA_BRADDR
, /* type */
569 2, /* size (0 = byte, 1 = short, 2 = long) */
571 true, /* pc_relative */
573 complain_overflow_signed
, /* complain_on_overflow */
574 0, /* special_function */
576 false, /* partial_inplace */
577 0x1fffff, /* src_mask */
578 0x1fffff, /* dst_mask */
579 true), /* pcrel_offset */
581 /* A hint for a jump to a register. */
582 HOWTO (R_ALPHA_HINT
, /* type */
584 1, /* size (0 = byte, 1 = short, 2 = long) */
586 true, /* pc_relative */
588 complain_overflow_dont
, /* complain_on_overflow */
589 0, /* special_function */
591 false, /* partial_inplace */
592 0x3fff, /* src_mask */
593 0x3fff, /* dst_mask */
594 true), /* pcrel_offset */
596 /* 16 bit PC relative offset. */
597 HOWTO (R_ALPHA_SREL16
, /* type */
599 1, /* size (0 = byte, 1 = short, 2 = long) */
601 true, /* pc_relative */
603 complain_overflow_signed
, /* complain_on_overflow */
604 0, /* special_function */
606 false, /* partial_inplace */
607 0xffff, /* src_mask */
608 0xffff, /* dst_mask */
609 true), /* pcrel_offset */
611 /* 32 bit PC relative offset. */
612 HOWTO (R_ALPHA_SREL32
, /* type */
614 2, /* size (0 = byte, 1 = short, 2 = long) */
616 true, /* pc_relative */
618 complain_overflow_signed
, /* complain_on_overflow */
619 0, /* special_function */
621 false, /* partial_inplace */
622 0xffffffff, /* src_mask */
623 0xffffffff, /* dst_mask */
624 true), /* pcrel_offset */
626 /* A 64 bit PC relative offset. */
627 HOWTO (R_ALPHA_SREL64
, /* type */
629 4, /* size (0 = byte, 1 = short, 2 = long) */
631 true, /* pc_relative */
633 complain_overflow_signed
, /* complain_on_overflow */
634 0, /* special_function */
636 false, /* partial_inplace */
637 MINUS_ONE
, /* src_mask */
638 MINUS_ONE
, /* dst_mask */
639 true), /* pcrel_offset */
641 /* Skip 12 - 16; deprecated ECOFF relocs. */
648 /* The high 16 bits of the displacement from GP to the target. */
649 HOWTO (R_ALPHA_GPRELHIGH
,
651 1, /* size (0 = byte, 1 = short, 2 = long) */
653 false, /* pc_relative */
655 complain_overflow_signed
, /* complain_on_overflow */
656 0, /* special_function */
657 "GPRELHIGH", /* name */
658 false, /* partial_inplace */
659 0xffff, /* src_mask */
660 0xffff, /* dst_mask */
661 false), /* pcrel_offset */
663 /* The low 16 bits of the displacement from GP to the target. */
664 HOWTO (R_ALPHA_GPRELLOW
,
666 1, /* size (0 = byte, 1 = short, 2 = long) */
668 false, /* pc_relative */
670 complain_overflow_dont
, /* complain_on_overflow */
671 0, /* special_function */
672 "GPRELLOW", /* name */
673 false, /* partial_inplace */
674 0xffff, /* src_mask */
675 0xffff, /* dst_mask */
676 false), /* pcrel_offset */
678 /* A 16-bit displacement from the GP to the target. */
679 HOWTO (R_ALPHA_GPREL16
,
681 1, /* size (0 = byte, 1 = short, 2 = long) */
683 false, /* pc_relative */
685 complain_overflow_signed
, /* complain_on_overflow */
686 0, /* special_function */
687 "GPREL16", /* name */
688 false, /* partial_inplace */
689 0xffff, /* src_mask */
690 0xffff, /* dst_mask */
691 false), /* pcrel_offset */
693 /* Skip 20 - 23; deprecated ECOFF relocs. */
699 /* Misc ELF relocations. */
701 /* A dynamic relocation to copy the target into our .dynbss section. */
702 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
703 is present because every other ELF has one, but should not be used
704 because .dynbss is an ugly thing. */
711 complain_overflow_dont
,
712 bfd_elf_generic_reloc
,
719 /* A dynamic relocation for a .got entry. */
720 HOWTO (R_ALPHA_GLOB_DAT
,
726 complain_overflow_dont
,
727 bfd_elf_generic_reloc
,
734 /* A dynamic relocation for a .plt entry. */
735 HOWTO (R_ALPHA_JMP_SLOT
,
741 complain_overflow_dont
,
742 bfd_elf_generic_reloc
,
749 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
750 HOWTO (R_ALPHA_RELATIVE
,
756 complain_overflow_dont
,
757 bfd_elf_generic_reloc
,
764 /* A 21 bit branch that adjusts for gp loads. */
765 HOWTO (R_ALPHA_BRSGP
, /* type */
767 2, /* size (0 = byte, 1 = short, 2 = long) */
769 true, /* pc_relative */
771 complain_overflow_signed
, /* complain_on_overflow */
772 0, /* special_function */
774 false, /* partial_inplace */
775 0x1fffff, /* src_mask */
776 0x1fffff, /* dst_mask */
777 true), /* pcrel_offset */
779 /* Creates a tls_index for the symbol in the got. */
780 HOWTO (R_ALPHA_TLSGD
, /* type */
782 1, /* size (0 = byte, 1 = short, 2 = long) */
784 false, /* pc_relative */
786 complain_overflow_signed
, /* complain_on_overflow */
787 0, /* special_function */
789 false, /* partial_inplace */
790 0xffff, /* src_mask */
791 0xffff, /* dst_mask */
792 false), /* pcrel_offset */
794 /* Creates a tls_index for the (current) module in the got. */
795 HOWTO (R_ALPHA_TLSLDM
, /* type */
797 1, /* size (0 = byte, 1 = short, 2 = long) */
799 false, /* pc_relative */
801 complain_overflow_signed
, /* complain_on_overflow */
802 0, /* special_function */
804 false, /* partial_inplace */
805 0xffff, /* src_mask */
806 0xffff, /* dst_mask */
807 false), /* pcrel_offset */
809 /* A dynamic relocation for a DTP module entry. */
810 HOWTO (R_ALPHA_DTPMOD64
, /* type */
812 4, /* size (0 = byte, 1 = short, 2 = long) */
814 false, /* pc_relative */
816 complain_overflow_bitfield
, /* complain_on_overflow */
817 0, /* special_function */
818 "DTPMOD64", /* name */
819 false, /* partial_inplace */
820 MINUS_ONE
, /* src_mask */
821 MINUS_ONE
, /* dst_mask */
822 false), /* pcrel_offset */
824 /* Creates a 64-bit offset in the got for the displacement
825 from DTP to the target. */
826 HOWTO (R_ALPHA_GOTDTPREL
, /* type */
828 1, /* size (0 = byte, 1 = short, 2 = long) */
830 false, /* pc_relative */
832 complain_overflow_signed
, /* complain_on_overflow */
833 0, /* special_function */
834 "GOTDTPREL", /* name */
835 false, /* partial_inplace */
836 0xffff, /* src_mask */
837 0xffff, /* dst_mask */
838 false), /* pcrel_offset */
840 /* A dynamic relocation for a displacement from DTP to the target. */
841 HOWTO (R_ALPHA_DTPREL64
, /* type */
843 4, /* size (0 = byte, 1 = short, 2 = long) */
845 false, /* pc_relative */
847 complain_overflow_bitfield
, /* complain_on_overflow */
848 0, /* special_function */
849 "DTPREL64", /* name */
850 false, /* partial_inplace */
851 MINUS_ONE
, /* src_mask */
852 MINUS_ONE
, /* dst_mask */
853 false), /* pcrel_offset */
855 /* The high 16 bits of the displacement from DTP to the target. */
856 HOWTO (R_ALPHA_DTPRELHI
, /* type */
858 1, /* size (0 = byte, 1 = short, 2 = long) */
860 false, /* pc_relative */
862 complain_overflow_signed
, /* complain_on_overflow */
863 0, /* special_function */
864 "DTPRELHI", /* name */
865 false, /* partial_inplace */
866 0xffff, /* src_mask */
867 0xffff, /* dst_mask */
868 false), /* pcrel_offset */
870 /* The low 16 bits of the displacement from DTP to the target. */
871 HOWTO (R_ALPHA_DTPRELLO
, /* type */
873 1, /* size (0 = byte, 1 = short, 2 = long) */
875 false, /* pc_relative */
877 complain_overflow_dont
, /* complain_on_overflow */
878 0, /* special_function */
879 "DTPRELLO", /* name */
880 false, /* partial_inplace */
881 0xffff, /* src_mask */
882 0xffff, /* dst_mask */
883 false), /* pcrel_offset */
885 /* A 16-bit displacement from DTP to the target. */
886 HOWTO (R_ALPHA_DTPREL16
, /* type */
888 1, /* size (0 = byte, 1 = short, 2 = long) */
890 false, /* pc_relative */
892 complain_overflow_signed
, /* complain_on_overflow */
893 0, /* special_function */
894 "DTPREL16", /* name */
895 false, /* partial_inplace */
896 0xffff, /* src_mask */
897 0xffff, /* dst_mask */
898 false), /* pcrel_offset */
900 /* Creates a 64-bit offset in the got for the displacement
901 from TP to the target. */
902 HOWTO (R_ALPHA_GOTTPREL
, /* type */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
906 false, /* pc_relative */
908 complain_overflow_signed
, /* complain_on_overflow */
909 0, /* special_function */
910 "GOTTPREL", /* name */
911 false, /* partial_inplace */
912 0xffff, /* src_mask */
913 0xffff, /* dst_mask */
914 false), /* pcrel_offset */
916 /* A dynamic relocation for a displacement from TP to the target. */
917 HOWTO (R_ALPHA_TPREL64
, /* type */
919 4, /* size (0 = byte, 1 = short, 2 = long) */
921 false, /* pc_relative */
923 complain_overflow_bitfield
, /* complain_on_overflow */
924 0, /* special_function */
925 "TPREL64", /* name */
926 false, /* partial_inplace */
927 MINUS_ONE
, /* src_mask */
928 MINUS_ONE
, /* dst_mask */
929 false), /* pcrel_offset */
931 /* The high 16 bits of the displacement from TP to the target. */
932 HOWTO (R_ALPHA_TPRELHI
, /* type */
934 1, /* size (0 = byte, 1 = short, 2 = long) */
936 false, /* pc_relative */
938 complain_overflow_signed
, /* complain_on_overflow */
939 0, /* special_function */
940 "TPRELHI", /* name */
941 false, /* partial_inplace */
942 0xffff, /* src_mask */
943 0xffff, /* dst_mask */
944 false), /* pcrel_offset */
946 /* The low 16 bits of the displacement from TP to the target. */
947 HOWTO (R_ALPHA_TPRELLO
, /* type */
949 1, /* size (0 = byte, 1 = short, 2 = long) */
951 false, /* pc_relative */
953 complain_overflow_dont
, /* complain_on_overflow */
954 0, /* special_function */
955 "TPRELLO", /* name */
956 false, /* partial_inplace */
957 0xffff, /* src_mask */
958 0xffff, /* dst_mask */
959 false), /* pcrel_offset */
961 /* A 16-bit displacement from TP to the target. */
962 HOWTO (R_ALPHA_TPREL16
, /* type */
964 1, /* size (0 = byte, 1 = short, 2 = long) */
966 false, /* pc_relative */
968 complain_overflow_signed
, /* complain_on_overflow */
969 0, /* special_function */
970 "TPREL16", /* name */
971 false, /* partial_inplace */
972 0xffff, /* src_mask */
973 0xffff, /* dst_mask */
974 false), /* pcrel_offset */
977 /* A relocation function which doesn't do anything. */
979 static bfd_reloc_status_type
980 elf64_alpha_reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
981 bfd
*abfd ATTRIBUTE_UNUSED
;
983 asymbol
*sym ATTRIBUTE_UNUSED
;
984 PTR data ATTRIBUTE_UNUSED
;
987 char **error_message ATTRIBUTE_UNUSED
;
990 reloc
->address
+= sec
->output_offset
;
994 /* A relocation function used for an unsupported reloc. */
996 static bfd_reloc_status_type
997 elf64_alpha_reloc_bad (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
998 bfd
*abfd ATTRIBUTE_UNUSED
;
1000 asymbol
*sym ATTRIBUTE_UNUSED
;
1001 PTR data ATTRIBUTE_UNUSED
;
1004 char **error_message ATTRIBUTE_UNUSED
;
1007 reloc
->address
+= sec
->output_offset
;
1008 return bfd_reloc_notsupported
;
1011 /* Do the work of the GPDISP relocation. */
1013 static bfd_reloc_status_type
1014 elf64_alpha_do_reloc_gpdisp (abfd
, gpdisp
, p_ldah
, p_lda
)
1020 bfd_reloc_status_type ret
= bfd_reloc_ok
;
1022 unsigned long i_ldah
, i_lda
;
1024 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
1025 i_lda
= bfd_get_32 (abfd
, p_lda
);
1027 /* Complain if the instructions are not correct. */
1028 if (((i_ldah
>> 26) & 0x3f) != 0x09
1029 || ((i_lda
>> 26) & 0x3f) != 0x08)
1030 ret
= bfd_reloc_dangerous
;
1032 /* Extract the user-supplied offset, mirroring the sign extensions
1033 that the instructions perform. */
1034 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
1035 addend
= (addend
^ 0x80008000) - 0x80008000;
1039 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
1040 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
1041 ret
= bfd_reloc_overflow
;
1043 /* compensate for the sign extension again. */
1044 i_ldah
= ((i_ldah
& 0xffff0000)
1045 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
1046 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
1048 bfd_put_32 (abfd
, (bfd_vma
) i_ldah
, p_ldah
);
1049 bfd_put_32 (abfd
, (bfd_vma
) i_lda
, p_lda
);
1054 /* The special function for the GPDISP reloc. */
1056 static bfd_reloc_status_type
1057 elf64_alpha_reloc_gpdisp (abfd
, reloc_entry
, sym
, data
, input_section
,
1058 output_bfd
, err_msg
)
1060 arelent
*reloc_entry
;
1061 asymbol
*sym ATTRIBUTE_UNUSED
;
1063 asection
*input_section
;
1067 bfd_reloc_status_type ret
;
1068 bfd_vma gp
, relocation
;
1069 bfd_byte
*p_ldah
, *p_lda
;
1071 /* Don't do anything if we're not doing a final link. */
1074 reloc_entry
->address
+= input_section
->output_offset
;
1075 return bfd_reloc_ok
;
1078 if (reloc_entry
->address
> input_section
->_cooked_size
||
1079 reloc_entry
->address
+ reloc_entry
->addend
> input_section
->_cooked_size
)
1080 return bfd_reloc_outofrange
;
1082 /* The gp used in the portion of the output object to which this
1083 input object belongs is cached on the input bfd. */
1084 gp
= _bfd_get_gp_value (abfd
);
1086 relocation
= (input_section
->output_section
->vma
1087 + input_section
->output_offset
1088 + reloc_entry
->address
);
1090 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
1091 p_lda
= p_ldah
+ reloc_entry
->addend
;
1093 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
1095 /* Complain if the instructions are not correct. */
1096 if (ret
== bfd_reloc_dangerous
)
1097 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
1102 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1104 struct elf_reloc_map
1106 bfd_reloc_code_real_type bfd_reloc_val
;
1110 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
1112 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
1113 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
1114 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
1115 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
1116 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
1117 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
1118 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
1119 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
1120 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
1121 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
1122 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
1123 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
1124 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
1125 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
1126 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
1127 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
1128 {BFD_RELOC_ALPHA_BRSGP
, R_ALPHA_BRSGP
},
1129 {BFD_RELOC_ALPHA_TLSGD
, R_ALPHA_TLSGD
},
1130 {BFD_RELOC_ALPHA_TLSLDM
, R_ALPHA_TLSLDM
},
1131 {BFD_RELOC_ALPHA_DTPMOD64
, R_ALPHA_DTPMOD64
},
1132 {BFD_RELOC_ALPHA_GOTDTPREL16
, R_ALPHA_GOTDTPREL
},
1133 {BFD_RELOC_ALPHA_DTPREL64
, R_ALPHA_DTPREL64
},
1134 {BFD_RELOC_ALPHA_DTPREL_HI16
, R_ALPHA_DTPRELHI
},
1135 {BFD_RELOC_ALPHA_DTPREL_LO16
, R_ALPHA_DTPRELLO
},
1136 {BFD_RELOC_ALPHA_DTPREL16
, R_ALPHA_DTPREL16
},
1137 {BFD_RELOC_ALPHA_GOTTPREL16
, R_ALPHA_GOTTPREL
},
1138 {BFD_RELOC_ALPHA_TPREL64
, R_ALPHA_TPREL64
},
1139 {BFD_RELOC_ALPHA_TPREL_HI16
, R_ALPHA_TPRELHI
},
1140 {BFD_RELOC_ALPHA_TPREL_LO16
, R_ALPHA_TPRELLO
},
1141 {BFD_RELOC_ALPHA_TPREL16
, R_ALPHA_TPREL16
},
1144 /* Given a BFD reloc type, return a HOWTO structure. */
1146 static reloc_howto_type
*
1147 elf64_alpha_bfd_reloc_type_lookup (abfd
, code
)
1148 bfd
*abfd ATTRIBUTE_UNUSED
;
1149 bfd_reloc_code_real_type code
;
1151 const struct elf_reloc_map
*i
, *e
;
1152 i
= e
= elf64_alpha_reloc_map
;
1153 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1156 if (i
->bfd_reloc_val
== code
)
1157 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1162 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1165 elf64_alpha_info_to_howto (abfd
, cache_ptr
, dst
)
1166 bfd
*abfd ATTRIBUTE_UNUSED
;
1168 Elf64_Internal_Rela
*dst
;
1172 r_type
= ELF64_R_TYPE(dst
->r_info
);
1173 BFD_ASSERT (r_type
< (unsigned int) R_ALPHA_max
);
1174 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1177 /* These two relocations create a two-word entry in the got. */
1178 #define alpha_got_entry_size(r_type) \
1179 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1181 /* This is PT_TLS segment p_vaddr. */
1182 #define alpha_get_dtprel_base(tlss) \
1185 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1186 is assigned offset round(16, PT_TLS p_align). */
1187 #define alpha_get_tprel_base(tlss) \
1188 ((tlss)->start - align_power ((bfd_vma) 16, (tlss)->align))
1190 /* These functions do relaxation for Alpha ELF.
1192 Currently I'm only handling what I can do with existing compiler
1193 and assembler support, which means no instructions are removed,
1194 though some may be nopped. At this time GCC does not emit enough
1195 information to do all of the relaxing that is possible. It will
1196 take some not small amount of work for that to happen.
1198 There are a couple of interesting papers that I once read on this
1199 subject, that I cannot find references to at the moment, that
1200 related to Alpha in particular. They are by David Wall, then of
1204 #define OP_LDAH 0x09
1205 #define INSN_JSR 0x68004000
1206 #define INSN_JSR_MASK 0xfc00c000
1210 #define INSN_UNOP 0x2ffe0000
1211 #define INSN_ADDQ 0x40000400
1212 #define INSN_RDUNIQ 0x0000009e
1214 struct alpha_relax_info
1219 Elf_Internal_Shdr
*symtab_hdr
;
1220 Elf_Internal_Rela
*relocs
, *relend
;
1221 struct bfd_link_info
*link_info
;
1222 struct elf_link_tls_segment
*tls_segment
;
1226 struct alpha_elf_link_hash_entry
*h
;
1227 struct alpha_elf_got_entry
**first_gotent
;
1228 struct alpha_elf_got_entry
*gotent
;
1229 boolean changed_contents
;
1230 boolean changed_relocs
;
1231 unsigned char other
;
1234 static boolean elf64_alpha_relax_with_lituse
1235 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1236 Elf_Internal_Rela
*irel
));
1237 static bfd_vma elf64_alpha_relax_opt_call
1238 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
));
1239 static boolean elf64_alpha_relax_got_load
1240 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1241 Elf_Internal_Rela
*irel
, unsigned long));
1242 static boolean elf64_alpha_relax_gprelhilo
1243 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1244 Elf_Internal_Rela
*irel
, boolean
));
1245 static boolean elf64_alpha_relax_tls_get_addr
1246 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1247 Elf_Internal_Rela
*irel
, boolean
));
1248 static struct elf_link_tls_segment
*elf64_alpha_relax_find_tls_segment
1249 PARAMS((struct alpha_relax_info
*, struct elf_link_tls_segment
*));
1250 static boolean elf64_alpha_relax_section
1251 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
1254 static Elf_Internal_Rela
*
1255 elf64_alpha_find_reloc_at_ofs (rel
, relend
, offset
, type
)
1256 Elf_Internal_Rela
*rel
, *relend
;
1260 while (rel
< relend
)
1262 if (rel
->r_offset
== offset
1263 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
1271 elf64_alpha_relax_with_lituse (info
, symval
, irel
)
1272 struct alpha_relax_info
*info
;
1274 Elf_Internal_Rela
*irel
;
1276 Elf_Internal_Rela
*urel
, *irelend
= info
->relend
;
1277 int flags
, count
, i
;
1278 bfd_signed_vma disp
;
1281 boolean lit_reused
= false;
1282 boolean all_optimized
= true;
1283 unsigned int lit_insn
;
1285 lit_insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1286 if (lit_insn
>> 26 != OP_LDQ
)
1288 ((*_bfd_error_handler
)
1289 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1290 bfd_archive_filename (info
->abfd
), info
->sec
->name
,
1291 (unsigned long) irel
->r_offset
));
1295 /* Can't relax dynamic symbols. */
1296 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
1299 /* Summarize how this particular LITERAL is used. */
1300 for (urel
= irel
+1, flags
= count
= 0; urel
< irelend
; ++urel
, ++count
)
1302 if (ELF64_R_TYPE (urel
->r_info
) != R_ALPHA_LITUSE
)
1304 if (urel
->r_addend
<= 3)
1305 flags
|= 1 << urel
->r_addend
;
1308 /* A little preparation for the loop... */
1309 disp
= symval
- info
->gp
;
1311 for (urel
= irel
+1, i
= 0; i
< count
; ++i
, ++urel
)
1315 bfd_signed_vma xdisp
;
1317 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ urel
->r_offset
);
1319 switch (urel
->r_addend
)
1321 case LITUSE_ALPHA_ADDR
:
1323 /* This type is really just a placeholder to note that all
1324 uses cannot be optimized, but to still allow some. */
1325 all_optimized
= false;
1328 case LITUSE_ALPHA_BASE
:
1329 /* We can always optimize 16-bit displacements. */
1331 /* Extract the displacement from the instruction, sign-extending
1332 it if necessary, then test whether it is within 16 or 32 bits
1333 displacement from GP. */
1334 insn_disp
= insn
& 0x0000ffff;
1335 if (insn_disp
& 0x8000)
1336 insn_disp
|= ~0xffff; /* Negative: sign-extend. */
1338 xdisp
= disp
+ insn_disp
;
1339 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x8000 && xdisp
< 0x8000);
1340 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000
1341 && xdisp
< 0x7fff8000);
1345 /* Take the op code and dest from this insn, take the base
1346 register from the literal insn. Leave the offset alone. */
1347 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
1348 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1350 urel
->r_addend
= irel
->r_addend
;
1351 info
->changed_relocs
= true;
1353 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1354 info
->contents
+ urel
->r_offset
);
1355 info
->changed_contents
= true;
1358 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1359 else if (fits32
&& !(flags
& ~6))
1361 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1363 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1365 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
1366 bfd_put_32 (info
->abfd
, (bfd_vma
) lit_insn
,
1367 info
->contents
+ irel
->r_offset
);
1369 info
->changed_contents
= true;
1371 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1373 urel
->r_addend
= irel
->r_addend
;
1374 info
->changed_relocs
= true;
1377 all_optimized
= false;
1380 case LITUSE_ALPHA_BYTOFF
:
1381 /* We can always optimize byte instructions. */
1383 /* FIXME: sanity check the insn for byte op. Check that the
1384 literal dest reg is indeed Rb in the byte insn. */
1386 insn
&= ~ (unsigned) 0x001ff000;
1387 insn
|= ((symval
& 7) << 13) | 0x1000;
1389 urel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1391 info
->changed_relocs
= true;
1393 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1394 info
->contents
+ urel
->r_offset
);
1395 info
->changed_contents
= true;
1398 case LITUSE_ALPHA_JSR
:
1399 case LITUSE_ALPHA_TLSGD
:
1400 case LITUSE_ALPHA_TLSLDM
:
1402 bfd_vma optdest
, org
;
1403 bfd_signed_vma odisp
;
1405 /* If not zero, place to jump without needing pv. */
1406 optdest
= elf64_alpha_relax_opt_call (info
, symval
);
1407 org
= (info
->sec
->output_section
->vma
1408 + info
->sec
->output_offset
1409 + urel
->r_offset
+ 4);
1410 odisp
= (optdest
? optdest
: symval
) - org
;
1412 if (odisp
>= -0x400000 && odisp
< 0x400000)
1414 Elf_Internal_Rela
*xrel
;
1416 /* Preserve branch prediction call stack when possible. */
1417 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
1418 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
1420 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
1422 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1424 urel
->r_addend
= irel
->r_addend
;
1427 urel
->r_addend
+= optdest
- symval
;
1429 all_optimized
= false;
1431 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1432 info
->contents
+ urel
->r_offset
);
1434 /* Kill any HINT reloc that might exist for this insn. */
1435 xrel
= (elf64_alpha_find_reloc_at_ofs
1436 (info
->relocs
, info
->relend
, urel
->r_offset
,
1439 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1441 info
->changed_contents
= true;
1442 info
->changed_relocs
= true;
1445 all_optimized
= false;
1447 /* Even if the target is not in range for a direct branch,
1448 if we share a GP, we can eliminate the gp reload. */
1451 Elf_Internal_Rela
*gpdisp
1452 = (elf64_alpha_find_reloc_at_ofs
1453 (info
->relocs
, irelend
, urel
->r_offset
+ 4,
1457 bfd_byte
*p_ldah
= info
->contents
+ gpdisp
->r_offset
;
1458 bfd_byte
*p_lda
= p_ldah
+ gpdisp
->r_addend
;
1459 unsigned int ldah
= bfd_get_32 (info
->abfd
, p_ldah
);
1460 unsigned int lda
= bfd_get_32 (info
->abfd
, p_lda
);
1462 /* Verify that the instruction is "ldah $29,0($26)".
1463 Consider a function that ends in a noreturn call,
1464 and that the next function begins with an ldgp,
1465 and that by accident there is no padding between.
1466 In that case the insn would use $27 as the base. */
1467 if (ldah
== 0x27ba0000 && lda
== 0x23bd0000)
1469 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_ldah
);
1470 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_lda
);
1472 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1473 info
->changed_contents
= true;
1474 info
->changed_relocs
= true;
1483 /* If all cases were optimized, we can reduce the use count on this
1484 got entry by one, possibly eliminating it. */
1487 if (--info
->gotent
->use_count
== 0)
1489 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
1490 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1492 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1495 /* If the literal instruction is no longer needed (it may have been
1496 reused. We can eliminate it. */
1497 /* ??? For now, I don't want to deal with compacting the section,
1498 so just nop it out. */
1501 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1502 info
->changed_relocs
= true;
1504 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
,
1505 info
->contents
+ irel
->r_offset
);
1506 info
->changed_contents
= true;
1514 elf64_alpha_relax_opt_call (info
, symval
)
1515 struct alpha_relax_info
*info
;
1518 /* If the function has the same gp, and we can identify that the
1519 function does not use its function pointer, we can eliminate the
1522 /* If the symbol is marked NOPV, we are being told the function never
1523 needs its procedure value. */
1524 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
1527 /* If the symbol is marked STD_GP, we are being told the function does
1528 a normal ldgp in the first two words. */
1529 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
1532 /* Otherwise, we may be able to identify a GP load in the first two
1533 words, which we can then skip. */
1536 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
1539 /* Load the relocations from the section that the target symbol is in. */
1540 if (info
->sec
== info
->tsec
)
1542 tsec_relocs
= info
->relocs
;
1543 tsec_relend
= info
->relend
;
1548 tsec_relocs
= (_bfd_elf64_link_read_relocs
1549 (info
->abfd
, info
->tsec
, (PTR
) NULL
,
1550 (Elf_Internal_Rela
*) NULL
,
1551 info
->link_info
->keep_memory
));
1552 if (tsec_relocs
== NULL
)
1554 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
1555 tsec_free
= (info
->link_info
->keep_memory
? NULL
: tsec_relocs
);
1558 /* Recover the symbol's offset within the section. */
1559 ofs
= (symval
- info
->tsec
->output_section
->vma
1560 - info
->tsec
->output_offset
);
1562 /* Look for a GPDISP reloc. */
1563 gpdisp
= (elf64_alpha_find_reloc_at_ofs
1564 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
1566 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
1576 /* We've now determined that we can skip an initial gp load. Verify
1577 that the call and the target use the same gp. */
1578 if (info
->link_info
->hash
->creator
!= info
->tsec
->owner
->xvec
1579 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
1586 elf64_alpha_relax_got_load (info
, symval
, irel
, r_type
)
1587 struct alpha_relax_info
*info
;
1589 Elf_Internal_Rela
*irel
;
1590 unsigned long r_type
;
1593 bfd_signed_vma disp
;
1595 /* Get the instruction. */
1596 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1598 if (insn
>> 26 != OP_LDQ
)
1600 reloc_howto_type
*howto
= elf64_alpha_howto_table
+ r_type
;
1601 ((*_bfd_error_handler
)
1602 ("%s: %s+0x%lx: warning: %s relocation against unexpected insn",
1603 bfd_archive_filename (info
->abfd
), info
->sec
->name
,
1604 (unsigned long) irel
->r_offset
, howto
->name
));
1608 /* Can't relax dynamic symbols. */
1609 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
1612 /* Can't use local-exec relocations in shared libraries. */
1613 if (r_type
== R_ALPHA_GOTTPREL
&& info
->link_info
->shared
)
1616 if (r_type
== R_ALPHA_LITERAL
)
1617 disp
= symval
- info
->gp
;
1620 bfd_vma dtp_base
, tp_base
;
1622 BFD_ASSERT (info
->tls_segment
!= NULL
);
1623 dtp_base
= alpha_get_dtprel_base (info
->tls_segment
);
1624 tp_base
= alpha_get_tprel_base (info
->tls_segment
);
1625 disp
= symval
- (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
1628 if (disp
< -0x8000 || disp
>= 0x8000)
1631 /* Exchange LDQ for LDA. In the case of the TLS relocs, we're loading
1632 a constant, so force the base register to be $31. */
1633 if (r_type
== R_ALPHA_LITERAL
)
1634 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
1636 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
1637 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, info
->contents
+ irel
->r_offset
);
1638 info
->changed_contents
= true;
1642 case R_ALPHA_LITERAL
:
1643 r_type
= R_ALPHA_GPREL16
;
1645 case R_ALPHA_GOTDTPREL
:
1646 r_type
= R_ALPHA_DTPREL16
;
1648 case R_ALPHA_GOTTPREL
:
1649 r_type
= R_ALPHA_TPREL16
;
1656 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), r_type
);
1657 info
->changed_relocs
= true;
1659 /* Reduce the use count on this got entry by one, possibly
1661 if (--info
->gotent
->use_count
== 0)
1663 int sz
= alpha_got_entry_size (r_type
);
1664 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1666 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1669 /* ??? Search forward through this basic block looking for insns
1670 that use the target register. Stop after an insn modifying the
1671 register is seen, or after a branch or call.
1673 Any such memory load insn may be substituted by a load directly
1674 off the GP. This allows the memory load insn to be issued before
1675 the calculated GP register would otherwise be ready.
1677 Any such jsr insn can be replaced by a bsr if it is in range.
1679 This would mean that we'd have to _add_ relocations, the pain of
1680 which gives one pause. */
1686 elf64_alpha_relax_gprelhilo (info
, symval
, irel
, hi
)
1687 struct alpha_relax_info
*info
;
1689 Elf_Internal_Rela
*irel
;
1693 bfd_signed_vma disp
;
1694 bfd_byte
*pos
= info
->contents
+ irel
->r_offset
;
1696 /* ??? This assumes that the compiler doesn't render
1700 ldah t, array(gp) !gprelhigh
1702 ldq r, array(t) !gprellow
1704 which would indeed be the most efficient way to implement this. */
1708 disp
= symval
- info
->gp
;
1709 if (disp
< -0x8000 || disp
>= 0x8000)
1714 /* Nop out the high instruction. */
1716 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
);
1717 info
->changed_contents
= true;
1719 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1721 info
->changed_relocs
= true;
1725 /* Adjust the low instruction to reference GP directly. */
1727 insn
= bfd_get_32 (info
->abfd
, pos
);
1728 insn
= (insn
& 0xffe00000) | (29 << 16);
1729 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
);
1730 info
->changed_contents
= true;
1732 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1734 info
->changed_relocs
= true;
1741 elf64_alpha_relax_tls_get_addr (info
, symval
, irel
, is_gd
)
1742 struct alpha_relax_info
*info
;
1744 Elf_Internal_Rela
*irel
;
1749 Elf_Internal_Rela
*gpdisp
, *hint
;
1750 boolean dynamic
, use_gottprel
;
1752 dynamic
= alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
);
1754 /* ??? For LD relaxation, we need a symbol referencing the beginning
1755 of the TLS segment. */
1759 /* If a TLS symbol is accessed using IE at least once, there is no point
1760 to use dynamic model for it. */
1761 if (is_gd
&& info
->h
&& (info
->h
->flags
& ALPHA_ELF_LINK_HASH_TLS_IE
))
1764 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
1765 then we might as well relax to IE. */
1766 else if (info
->link_info
->shared
&& !dynamic
1767 && (info
->link_info
->flags
& DF_STATIC_TLS
))
1770 /* Otherwise we must be building an executable to do anything. */
1771 else if (info
->link_info
->shared
)
1774 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
1775 the matching LITUSE_TLS relocations. */
1776 if (irel
+ 2 >= info
->relend
)
1778 if (ELF64_R_TYPE (irel
[1].r_info
) != R_ALPHA_LITERAL
1779 || ELF64_R_TYPE (irel
[2].r_info
) != R_ALPHA_LITUSE
1780 || irel
[2].r_addend
!= (is_gd
? LITUSE_ALPHA_TLSGD
: LITUSE_ALPHA_TLSLDM
))
1783 /* There must be a GPDISP relocation positioned immediately after the
1784 LITUSE relocation. */
1785 gpdisp
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
1786 irel
[2].r_offset
+ 4, R_ALPHA_GPDISP
);
1790 pos
[0] = info
->contents
+ irel
[0].r_offset
;
1791 pos
[1] = info
->contents
+ irel
[1].r_offset
;
1792 pos
[2] = info
->contents
+ irel
[2].r_offset
;
1793 pos
[3] = info
->contents
+ gpdisp
->r_offset
;
1794 pos
[4] = pos
[3] + gpdisp
->r_addend
;
1796 /* Only positions 0 and 1 are allowed to be out of order. */
1797 if (pos
[1] < pos
[0])
1799 bfd_byte
*tmp
= pos
[0];
1803 if (pos
[1] >= pos
[2] || pos
[2] >= pos
[3] || pos
[3] >= pos
[4])
1806 /* Reduce the use count on the LITERAL relocation. Do this before we
1807 smash the symndx when we adjust the relocations below. */
1809 struct alpha_elf_got_entry
*lit_gotent
;
1810 struct alpha_elf_link_hash_entry
*lit_h
;
1813 BFD_ASSERT (ELF64_R_SYM (irel
[1].r_info
) >= info
->symtab_hdr
->sh_info
);
1814 indx
= ELF64_R_SYM (irel
[1].r_info
) - info
->symtab_hdr
->sh_info
;
1815 lit_h
= alpha_elf_sym_hashes (info
->abfd
)[indx
];
1817 while (lit_h
->root
.root
.type
== bfd_link_hash_indirect
1818 || lit_h
->root
.root
.type
== bfd_link_hash_warning
)
1819 lit_h
= (struct alpha_elf_link_hash_entry
*) lit_h
->root
.root
.u
.i
.link
;
1821 for (lit_gotent
= lit_h
->got_entries
; lit_gotent
;
1822 lit_gotent
= lit_gotent
->next
)
1823 if (lit_gotent
->gotobj
== info
->gotobj
1824 && lit_gotent
->reloc_type
== R_ALPHA_LITERAL
1825 && lit_gotent
->addend
== irel
[1].r_addend
)
1827 BFD_ASSERT (lit_gotent
);
1829 if (--lit_gotent
->use_count
== 0)
1831 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
1832 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1838 lda $16,x($gp) !tlsgd!1
1839 ldq $27,__tls_get_addr($gp) !literal!1
1840 jsr $26,($27)__tls_get_addr !lituse_tlsgd!1
1841 ldah $29,0($26) !gpdisp!2
1842 lda $29,0($29) !gpdisp!2
1844 ldq $16,x($gp) !gottprel
1849 or the first pair to
1850 lda $16,x($gp) !tprel
1853 ldah $16,x($gp) !tprelhi
1854 lda $16,x($16) !tprello
1858 use_gottprel
= false;
1859 switch (!dynamic
&& !info
->link_info
->shared
)
1864 bfd_signed_vma disp
;
1866 BFD_ASSERT (info
->tls_segment
!= NULL
);
1867 tp_base
= alpha_get_tprel_base (info
->tls_segment
);
1868 disp
= symval
- tp_base
;
1870 if (disp
>= -0x8000 && disp
< 0x8000)
1872 insn
= (OP_LDA
<< 26) | (16 << 21) | (31 << 16);
1873 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1874 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
1876 irel
[0].r_offset
= pos
[0] - info
->contents
;
1877 irel
[0].r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1879 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1882 else if (disp
>= -(bfd_signed_vma
) 0x80000000
1883 && disp
< (bfd_signed_vma
) 0x7fff8000)
1885 insn
= (OP_LDAH
<< 26) | (16 << 21) | (31 << 16);
1886 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1887 insn
= (OP_LDA
<< 26) | (16 << 21) | (16 << 16);
1888 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[1]);
1890 irel
[0].r_offset
= pos
[0] - info
->contents
;
1891 irel
[0].r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1893 irel
[1].r_offset
= pos
[1] - info
->contents
;
1894 irel
[1].r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1902 use_gottprel
= true;
1904 insn
= (OP_LDQ
<< 26) | (16 << 21) | (29 << 16);
1905 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1906 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
1908 irel
[0].r_offset
= pos
[0] - info
->contents
;
1909 irel
[0].r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1911 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1915 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_RDUNIQ
, pos
[2]);
1917 insn
= INSN_ADDQ
| (16 << 21) | (0 << 16) | (0 << 0);
1918 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[3]);
1920 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[4]);
1922 irel
[2].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1923 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1925 hint
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
1926 irel
[2].r_offset
, R_ALPHA_HINT
);
1928 hint
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1930 info
->changed_contents
= true;
1931 info
->changed_relocs
= true;
1933 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
1934 if (--info
->gotent
->use_count
== 0)
1936 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
1937 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1939 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1942 /* If we've switched to a GOTTPREL relocation, increment the reference
1943 count on that got entry. */
1946 struct alpha_elf_got_entry
*tprel_gotent
;
1948 for (tprel_gotent
= *info
->first_gotent
; tprel_gotent
;
1949 tprel_gotent
= tprel_gotent
->next
)
1950 if (tprel_gotent
->gotobj
== info
->gotobj
1951 && tprel_gotent
->reloc_type
== R_ALPHA_GOTTPREL
1952 && tprel_gotent
->addend
== irel
->r_addend
)
1955 tprel_gotent
->use_count
++;
1958 if (info
->gotent
->use_count
== 0)
1959 tprel_gotent
= info
->gotent
;
1962 tprel_gotent
= (struct alpha_elf_got_entry
*)
1963 bfd_alloc (info
->abfd
, sizeof (struct alpha_elf_got_entry
));
1967 tprel_gotent
->next
= *info
->first_gotent
;
1968 *info
->first_gotent
= tprel_gotent
;
1970 tprel_gotent
->gotobj
= info
->gotobj
;
1971 tprel_gotent
->addend
= irel
->r_addend
;
1972 tprel_gotent
->got_offset
= -1;
1973 tprel_gotent
->reloc_done
= 0;
1974 tprel_gotent
->reloc_xlated
= 0;
1977 tprel_gotent
->use_count
= 1;
1978 tprel_gotent
->reloc_type
= R_ALPHA_GOTTPREL
;
1985 static struct elf_link_tls_segment
*
1986 elf64_alpha_relax_find_tls_segment (info
, seg
)
1987 struct alpha_relax_info
*info
;
1988 struct elf_link_tls_segment
*seg
;
1990 bfd
*output_bfd
= info
->sec
->output_section
->owner
;
1995 for (o
= output_bfd
->sections
; o
; o
= o
->next
)
1996 if ((o
->flags
& SEC_THREAD_LOCAL
) != 0
1997 && (o
->flags
& SEC_LOAD
) != 0)
2009 if (bfd_get_section_alignment (output_bfd
, o
) > align
)
2010 align
= bfd_get_section_alignment (output_bfd
, o
);
2012 size
= o
->_raw_size
;
2013 if (size
== 0 && (o
->flags
& SEC_HAS_CONTENTS
) == 0)
2015 struct bfd_link_order
*lo
;
2016 for (lo
= o
->link_order_head
; lo
; lo
= lo
->next
)
2017 if (size
< lo
->offset
+ lo
->size
)
2018 size
= lo
->offset
+ lo
->size
;
2020 end
= o
->vma
+ size
;
2023 while (o
&& (o
->flags
& SEC_THREAD_LOCAL
));
2026 seg
->size
= end
- base
;
2033 elf64_alpha_relax_section (abfd
, sec
, link_info
, again
)
2036 struct bfd_link_info
*link_info
;
2039 Elf_Internal_Shdr
*symtab_hdr
;
2040 Elf_Internal_Shdr
*shndx_hdr
;
2041 Elf_Internal_Rela
*internal_relocs
;
2042 Elf_Internal_Rela
*free_relocs
= NULL
;
2043 Elf_Internal_Rela
*irel
, *irelend
;
2044 bfd_byte
*free_contents
= NULL
;
2045 Elf64_External_Sym
*extsyms
;
2046 Elf64_External_Sym
*free_extsyms
= NULL
;
2047 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
2048 struct alpha_elf_got_entry
**local_got_entries
;
2049 struct alpha_relax_info info
;
2050 struct elf_link_tls_segment tls_segment
;
2052 /* We are not currently changing any sizes, so only one pass. */
2055 if (link_info
->relocateable
2056 || (sec
->flags
& SEC_RELOC
) == 0
2057 || sec
->reloc_count
== 0)
2060 /* If this is the first time we have been called for this section,
2061 initialize the cooked size. */
2062 if (sec
->_cooked_size
== 0)
2063 sec
->_cooked_size
= sec
->_raw_size
;
2065 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2066 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2068 /* Load the relocations for this section. */
2069 internal_relocs
= (_bfd_elf64_link_read_relocs
2070 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
2071 link_info
->keep_memory
));
2072 if (internal_relocs
== NULL
)
2074 if (! link_info
->keep_memory
)
2075 free_relocs
= internal_relocs
;
2077 memset(&info
, 0, sizeof (info
));
2080 info
.link_info
= link_info
;
2081 info
.symtab_hdr
= symtab_hdr
;
2082 info
.relocs
= internal_relocs
;
2083 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
2085 /* Find the GP for this object. Do not store the result back via
2086 _bfd_set_gp_value, since this could change again before final. */
2087 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
2090 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
2091 info
.gp
= (sgot
->output_section
->vma
2092 + sgot
->output_offset
2096 /* Get the section contents. */
2097 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2098 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
2101 info
.contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
2102 if (info
.contents
== NULL
)
2104 free_contents
= info
.contents
;
2106 if (! bfd_get_section_contents (abfd
, sec
, info
.contents
,
2107 (file_ptr
) 0, sec
->_raw_size
))
2111 /* Read this BFD's symbols. */
2112 if (symtab_hdr
->contents
!= NULL
)
2113 extsyms
= (Elf64_External_Sym
*) symtab_hdr
->contents
;
2116 bfd_size_type amt
= symtab_hdr
->sh_info
* sizeof (Elf64_External_Sym
);
2117 extsyms
= (Elf64_External_Sym
*) bfd_malloc (amt
);
2118 if (extsyms
== NULL
)
2120 free_extsyms
= extsyms
;
2121 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2122 || bfd_bread ((PTR
) extsyms
, amt
, abfd
) != amt
)
2126 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2127 if (shndx_hdr
->sh_size
!= 0)
2130 amt
= symtab_hdr
->sh_info
* sizeof (Elf_External_Sym_Shndx
);
2131 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
2132 if (shndx_buf
== NULL
)
2134 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
2135 || bfd_bread ((PTR
) shndx_buf
, amt
, abfd
) != amt
)
2139 /* Compute the TLS segment information. The version normally found in
2140 elf_hash_table (link_info)->tls_segment isn't built until final_link.
2141 ??? Probably should look into extracting this into a common function. */
2142 info
.tls_segment
= elf64_alpha_relax_find_tls_segment (&info
, &tls_segment
);
2144 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2147 Elf_Internal_Sym isym
;
2148 struct alpha_elf_got_entry
*gotent
;
2149 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
2151 /* Early exit for unhandled or unrelaxable relocations. */
2154 case R_ALPHA_LITERAL
:
2155 case R_ALPHA_GPRELHIGH
:
2156 case R_ALPHA_GPRELLOW
:
2157 case R_ALPHA_GOTDTPREL
:
2158 case R_ALPHA_GOTTPREL
:
2160 case R_ALPHA_TLSLDM
:
2166 /* Get the value of the symbol referred to by the reloc. */
2167 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2169 /* A local symbol. */
2170 Elf64_External_Sym
*esym
;
2171 Elf_External_Sym_Shndx
*shndx
;
2173 esym
= extsyms
+ ELF64_R_SYM (irel
->r_info
);
2174 shndx
= shndx_buf
+ (shndx_buf
? ELF64_R_SYM (irel
->r_info
) : 0);
2175 bfd_elf64_swap_symbol_in (abfd
, (const PTR
) esym
, (const PTR
) shndx
,
2177 if (isym
.st_shndx
== SHN_UNDEF
)
2179 else if (isym
.st_shndx
== SHN_ABS
)
2180 info
.tsec
= bfd_abs_section_ptr
;
2181 else if (isym
.st_shndx
== SHN_COMMON
)
2182 info
.tsec
= bfd_com_section_ptr
;
2184 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
2187 info
.other
= isym
.st_other
;
2188 info
.first_gotent
= &local_got_entries
[ELF64_R_SYM(irel
->r_info
)];
2189 symval
= isym
.st_value
;
2194 struct alpha_elf_link_hash_entry
*h
;
2196 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2197 h
= alpha_elf_sym_hashes (abfd
)[indx
];
2198 BFD_ASSERT (h
!= NULL
);
2200 while (h
->root
.root
.type
== bfd_link_hash_indirect
2201 || h
->root
.root
.type
== bfd_link_hash_warning
)
2202 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2204 /* If the symbol is undefined, we can't do anything with it. */
2205 if (h
->root
.root
.type
== bfd_link_hash_undefweak
2206 || h
->root
.root
.type
== bfd_link_hash_undefined
)
2209 /* If the symbol isn't defined in the current module, again
2210 we can't do anything. */
2211 if (!(h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2215 info
.tsec
= h
->root
.root
.u
.def
.section
;
2216 info
.other
= h
->root
.other
;
2217 info
.first_gotent
= &h
->got_entries
;
2218 symval
= h
->root
.root
.u
.def
.value
;
2221 /* Search for the got entry to be used by this relocation. */
2222 for (gotent
= *info
.first_gotent
; gotent
; gotent
= gotent
->next
)
2223 if (gotent
->gotobj
== info
.gotobj
2224 && gotent
->reloc_type
== r_type
2225 && gotent
->addend
== irel
->r_addend
)
2227 info
.gotent
= gotent
;
2229 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
2230 symval
+= irel
->r_addend
;
2234 case R_ALPHA_LITERAL
:
2235 BFD_ASSERT(info
.gotent
!= NULL
);
2237 /* If there exist LITUSE relocations immediately following, this
2238 opens up all sorts of interesting optimizations, because we
2239 now know every location that this address load is used. */
2240 if (irel
+1 < irelend
2241 && ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
2243 if (!elf64_alpha_relax_with_lituse (&info
, symval
, irel
))
2248 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
2253 case R_ALPHA_GPRELHIGH
:
2254 case R_ALPHA_GPRELLOW
:
2255 if (!elf64_alpha_relax_gprelhilo (&info
, symval
, irel
,
2256 r_type
== R_ALPHA_GPRELHIGH
))
2260 case R_ALPHA_GOTDTPREL
:
2261 case R_ALPHA_GOTTPREL
:
2262 BFD_ASSERT(info
.gotent
!= NULL
);
2263 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
2268 case R_ALPHA_TLSLDM
:
2269 BFD_ASSERT(info
.gotent
!= NULL
);
2270 if (!elf64_alpha_relax_tls_get_addr (&info
, symval
, irel
,
2271 r_type
== R_ALPHA_TLSGD
))
2277 if (!elf64_alpha_size_plt_section (link_info
))
2279 if (!elf64_alpha_size_got_sections (link_info
))
2281 if (!elf64_alpha_size_rela_got_section (link_info
))
2284 if (info
.changed_relocs
)
2285 elf_section_data (sec
)->relocs
= internal_relocs
;
2286 else if (free_relocs
!= NULL
)
2289 if (info
.changed_contents
)
2290 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
2291 else if (free_contents
!= NULL
)
2293 if (! link_info
->keep_memory
)
2294 free (free_contents
);
2297 /* Cache the section contents for elf_link_input_bfd. */
2298 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
2302 if (shndx_buf
!= NULL
)
2305 if (free_extsyms
!= NULL
)
2307 if (! link_info
->keep_memory
)
2308 free (free_extsyms
);
2311 /* Cache the symbols for elf_link_input_bfd. */
2312 symtab_hdr
->contents
= (unsigned char *) extsyms
;
2316 *again
= info
.changed_contents
|| info
.changed_relocs
;
2321 if (free_relocs
!= NULL
)
2323 if (free_contents
!= NULL
)
2324 free (free_contents
);
2325 if (shndx_buf
!= NULL
)
2327 if (free_extsyms
!= NULL
)
2328 free (free_extsyms
);
2333 #define PLT_HEADER_SIZE 32
2334 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
2335 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
2336 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
2337 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
2339 #define PLT_ENTRY_SIZE 12
2340 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
2341 #define PLT_ENTRY_WORD2 0
2342 #define PLT_ENTRY_WORD3 0
2344 #define MAX_GOT_SIZE (64*1024)
2346 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
2348 /* Handle an Alpha specific section when reading an object file. This
2349 is called when elfcode.h finds a section with an unknown type.
2350 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
2354 elf64_alpha_section_from_shdr (abfd
, hdr
, name
)
2356 Elf64_Internal_Shdr
*hdr
;
2361 /* There ought to be a place to keep ELF backend specific flags, but
2362 at the moment there isn't one. We just keep track of the
2363 sections by their name, instead. Fortunately, the ABI gives
2364 suggested names for all the MIPS specific sections, so we will
2365 probably get away with this. */
2366 switch (hdr
->sh_type
)
2368 case SHT_ALPHA_DEBUG
:
2369 if (strcmp (name
, ".mdebug") != 0)
2376 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
2378 newsect
= hdr
->bfd_section
;
2380 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
2382 if (! bfd_set_section_flags (abfd
, newsect
,
2383 (bfd_get_section_flags (abfd
, newsect
)
2391 /* Convert Alpha specific section flags to bfd internal section flags. */
2394 elf64_alpha_section_flags (flags
, hdr
)
2396 Elf64_Internal_Shdr
*hdr
;
2398 if (hdr
->sh_flags
& SHF_ALPHA_GPREL
)
2399 *flags
|= SEC_SMALL_DATA
;
2404 /* Set the correct type for an Alpha ELF section. We do this by the
2405 section name, which is a hack, but ought to work. */
2408 elf64_alpha_fake_sections (abfd
, hdr
, sec
)
2410 Elf64_Internal_Shdr
*hdr
;
2413 register const char *name
;
2415 name
= bfd_get_section_name (abfd
, sec
);
2417 if (strcmp (name
, ".mdebug") == 0)
2419 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
2420 /* In a shared object on Irix 5.3, the .mdebug section has an
2421 entsize of 0. FIXME: Does this matter? */
2422 if ((abfd
->flags
& DYNAMIC
) != 0 )
2423 hdr
->sh_entsize
= 0;
2425 hdr
->sh_entsize
= 1;
2427 else if ((sec
->flags
& SEC_SMALL_DATA
)
2428 || strcmp (name
, ".sdata") == 0
2429 || strcmp (name
, ".sbss") == 0
2430 || strcmp (name
, ".lit4") == 0
2431 || strcmp (name
, ".lit8") == 0)
2432 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
2437 /* Hook called by the linker routine which adds symbols from an object
2438 file. We use it to put .comm items in .sbss, and not .bss. */
2441 elf64_alpha_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
2443 struct bfd_link_info
*info
;
2444 const Elf_Internal_Sym
*sym
;
2445 const char **namep ATTRIBUTE_UNUSED
;
2446 flagword
*flagsp ATTRIBUTE_UNUSED
;
2450 if (sym
->st_shndx
== SHN_COMMON
2451 && !info
->relocateable
2452 && sym
->st_size
<= elf_gp_size (abfd
))
2454 /* Common symbols less than or equal to -G nn bytes are
2455 automatically put into .sbss. */
2457 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
2461 scomm
= bfd_make_section (abfd
, ".scommon");
2463 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
2465 | SEC_LINKER_CREATED
)))
2470 *valp
= sym
->st_size
;
2476 /* Create the .got section. */
2479 elf64_alpha_create_got_section(abfd
, info
)
2481 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2485 if (bfd_get_section_by_name (abfd
, ".got"))
2488 s
= bfd_make_section (abfd
, ".got");
2490 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2493 | SEC_LINKER_CREATED
))
2494 || !bfd_set_section_alignment (abfd
, s
, 3))
2497 alpha_elf_tdata (abfd
)->got
= s
;
2502 /* Create all the dynamic sections. */
2505 elf64_alpha_create_dynamic_sections (abfd
, info
)
2507 struct bfd_link_info
*info
;
2510 struct elf_link_hash_entry
*h
;
2512 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2514 s
= bfd_make_section (abfd
, ".plt");
2516 || ! bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2519 | SEC_LINKER_CREATED
2521 || ! bfd_set_section_alignment (abfd
, s
, 3))
2524 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2527 if (! (_bfd_generic_link_add_one_symbol
2528 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2529 (bfd_vma
) 0, (const char *) NULL
, false,
2530 get_elf_backend_data (abfd
)->collect
,
2531 (struct bfd_link_hash_entry
**) &h
)))
2533 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2534 h
->type
= STT_OBJECT
;
2537 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2540 s
= bfd_make_section (abfd
, ".rela.plt");
2542 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2545 | SEC_LINKER_CREATED
2547 || ! bfd_set_section_alignment (abfd
, s
, 3))
2550 /* We may or may not have created a .got section for this object, but
2551 we definitely havn't done the rest of the work. */
2553 if (!elf64_alpha_create_got_section (abfd
, info
))
2556 s
= bfd_make_section(abfd
, ".rela.got");
2558 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2561 | SEC_LINKER_CREATED
2563 || !bfd_set_section_alignment (abfd
, s
, 3))
2566 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2567 dynobj's .got section. We don't do this in the linker script
2568 because we don't want to define the symbol if we are not creating
2569 a global offset table. */
2571 if (!(_bfd_generic_link_add_one_symbol
2572 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
,
2573 alpha_elf_tdata(abfd
)->got
, (bfd_vma
) 0, (const char *) NULL
,
2574 false, get_elf_backend_data (abfd
)->collect
,
2575 (struct bfd_link_hash_entry
**) &h
)))
2577 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
2578 h
->type
= STT_OBJECT
;
2581 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
2584 elf_hash_table (info
)->hgot
= h
;
2589 /* Read ECOFF debugging information from a .mdebug section into a
2590 ecoff_debug_info structure. */
2593 elf64_alpha_read_ecoff_info (abfd
, section
, debug
)
2596 struct ecoff_debug_info
*debug
;
2599 const struct ecoff_debug_swap
*swap
;
2600 char *ext_hdr
= NULL
;
2602 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2603 memset (debug
, 0, sizeof (*debug
));
2605 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
2606 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2609 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2610 swap
->external_hdr_size
))
2613 symhdr
= &debug
->symbolic_header
;
2614 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2616 /* The symbolic header contains absolute file offsets and sizes to
2618 #define READ(ptr, offset, count, size, type) \
2619 if (symhdr->count == 0) \
2620 debug->ptr = NULL; \
2623 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2624 debug->ptr = (type) bfd_malloc (amt); \
2625 if (debug->ptr == NULL) \
2626 goto error_return; \
2627 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2628 || bfd_bread (debug->ptr, amt, abfd) != amt) \
2629 goto error_return; \
2632 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2633 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2634 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2635 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2636 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2637 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2639 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2640 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2641 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2642 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2643 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2647 debug
->adjust
= NULL
;
2652 if (ext_hdr
!= NULL
)
2654 if (debug
->line
!= NULL
)
2656 if (debug
->external_dnr
!= NULL
)
2657 free (debug
->external_dnr
);
2658 if (debug
->external_pdr
!= NULL
)
2659 free (debug
->external_pdr
);
2660 if (debug
->external_sym
!= NULL
)
2661 free (debug
->external_sym
);
2662 if (debug
->external_opt
!= NULL
)
2663 free (debug
->external_opt
);
2664 if (debug
->external_aux
!= NULL
)
2665 free (debug
->external_aux
);
2666 if (debug
->ss
!= NULL
)
2668 if (debug
->ssext
!= NULL
)
2669 free (debug
->ssext
);
2670 if (debug
->external_fdr
!= NULL
)
2671 free (debug
->external_fdr
);
2672 if (debug
->external_rfd
!= NULL
)
2673 free (debug
->external_rfd
);
2674 if (debug
->external_ext
!= NULL
)
2675 free (debug
->external_ext
);
2679 /* Alpha ELF local labels start with '$'. */
2682 elf64_alpha_is_local_label_name (abfd
, name
)
2683 bfd
*abfd ATTRIBUTE_UNUSED
;
2686 return name
[0] == '$';
2689 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2690 routine in order to handle the ECOFF debugging information. We
2691 still call this mips_elf_find_line because of the slot
2692 find_line_info in elf_obj_tdata is declared that way. */
2694 struct mips_elf_find_line
2696 struct ecoff_debug_info d
;
2697 struct ecoff_find_line i
;
2701 elf64_alpha_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2702 functionname_ptr
, line_ptr
)
2707 const char **filename_ptr
;
2708 const char **functionname_ptr
;
2709 unsigned int *line_ptr
;
2713 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2714 filename_ptr
, functionname_ptr
,
2716 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2719 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2723 struct mips_elf_find_line
*fi
;
2724 const struct ecoff_debug_swap
* const swap
=
2725 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2727 /* If we are called during a link, alpha_elf_final_link may have
2728 cleared the SEC_HAS_CONTENTS field. We force it back on here
2729 if appropriate (which it normally will be). */
2730 origflags
= msec
->flags
;
2731 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2732 msec
->flags
|= SEC_HAS_CONTENTS
;
2734 fi
= elf_tdata (abfd
)->find_line_info
;
2737 bfd_size_type external_fdr_size
;
2740 struct fdr
*fdr_ptr
;
2741 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
2743 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
2746 msec
->flags
= origflags
;
2750 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
2752 msec
->flags
= origflags
;
2756 /* Swap in the FDR information. */
2757 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
2758 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
2759 if (fi
->d
.fdr
== NULL
)
2761 msec
->flags
= origflags
;
2764 external_fdr_size
= swap
->external_fdr_size
;
2765 fdr_ptr
= fi
->d
.fdr
;
2766 fraw_src
= (char *) fi
->d
.external_fdr
;
2767 fraw_end
= (fraw_src
2768 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2769 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2770 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2772 elf_tdata (abfd
)->find_line_info
= fi
;
2774 /* Note that we don't bother to ever free this information.
2775 find_nearest_line is either called all the time, as in
2776 objdump -l, so the information should be saved, or it is
2777 rarely called, as in ld error messages, so the memory
2778 wasted is unimportant. Still, it would probably be a
2779 good idea for free_cached_info to throw it away. */
2782 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2783 &fi
->i
, filename_ptr
, functionname_ptr
,
2786 msec
->flags
= origflags
;
2790 msec
->flags
= origflags
;
2793 /* Fall back on the generic ELF find_nearest_line routine. */
2795 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2796 filename_ptr
, functionname_ptr
,
2800 /* Structure used to pass information to alpha_elf_output_extsym. */
2805 struct bfd_link_info
*info
;
2806 struct ecoff_debug_info
*debug
;
2807 const struct ecoff_debug_swap
*swap
;
2812 elf64_alpha_output_extsym (h
, data
)
2813 struct alpha_elf_link_hash_entry
*h
;
2816 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2818 asection
*sec
, *output_section
;
2820 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2821 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2823 if (h
->root
.indx
== -2)
2825 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2826 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2827 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2828 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2830 else if (einfo
->info
->strip
== strip_all
2831 || (einfo
->info
->strip
== strip_some
2832 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2833 h
->root
.root
.root
.string
,
2834 false, false) == NULL
))
2842 if (h
->esym
.ifd
== -2)
2845 h
->esym
.cobol_main
= 0;
2846 h
->esym
.weakext
= 0;
2847 h
->esym
.reserved
= 0;
2848 h
->esym
.ifd
= ifdNil
;
2849 h
->esym
.asym
.value
= 0;
2850 h
->esym
.asym
.st
= stGlobal
;
2852 if (h
->root
.root
.type
!= bfd_link_hash_defined
2853 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2854 h
->esym
.asym
.sc
= scAbs
;
2859 sec
= h
->root
.root
.u
.def
.section
;
2860 output_section
= sec
->output_section
;
2862 /* When making a shared library and symbol h is the one from
2863 the another shared library, OUTPUT_SECTION may be null. */
2864 if (output_section
== NULL
)
2865 h
->esym
.asym
.sc
= scUndefined
;
2868 name
= bfd_section_name (output_section
->owner
, output_section
);
2870 if (strcmp (name
, ".text") == 0)
2871 h
->esym
.asym
.sc
= scText
;
2872 else if (strcmp (name
, ".data") == 0)
2873 h
->esym
.asym
.sc
= scData
;
2874 else if (strcmp (name
, ".sdata") == 0)
2875 h
->esym
.asym
.sc
= scSData
;
2876 else if (strcmp (name
, ".rodata") == 0
2877 || strcmp (name
, ".rdata") == 0)
2878 h
->esym
.asym
.sc
= scRData
;
2879 else if (strcmp (name
, ".bss") == 0)
2880 h
->esym
.asym
.sc
= scBss
;
2881 else if (strcmp (name
, ".sbss") == 0)
2882 h
->esym
.asym
.sc
= scSBss
;
2883 else if (strcmp (name
, ".init") == 0)
2884 h
->esym
.asym
.sc
= scInit
;
2885 else if (strcmp (name
, ".fini") == 0)
2886 h
->esym
.asym
.sc
= scFini
;
2888 h
->esym
.asym
.sc
= scAbs
;
2892 h
->esym
.asym
.reserved
= 0;
2893 h
->esym
.asym
.index
= indexNil
;
2896 if (h
->root
.root
.type
== bfd_link_hash_common
)
2897 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2898 else if (h
->root
.root
.type
== bfd_link_hash_defined
2899 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2901 if (h
->esym
.asym
.sc
== scCommon
)
2902 h
->esym
.asym
.sc
= scBss
;
2903 else if (h
->esym
.asym
.sc
== scSCommon
)
2904 h
->esym
.asym
.sc
= scSBss
;
2906 sec
= h
->root
.root
.u
.def
.section
;
2907 output_section
= sec
->output_section
;
2908 if (output_section
!= NULL
)
2909 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2910 + sec
->output_offset
2911 + output_section
->vma
);
2913 h
->esym
.asym
.value
= 0;
2915 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2917 /* Set type and value for a symbol with a function stub. */
2918 h
->esym
.asym
.st
= stProc
;
2919 sec
= bfd_get_section_by_name (einfo
->abfd
, ".plt");
2921 h
->esym
.asym
.value
= 0;
2924 output_section
= sec
->output_section
;
2925 if (output_section
!= NULL
)
2926 h
->esym
.asym
.value
= (h
->root
.plt
.offset
2927 + sec
->output_offset
2928 + output_section
->vma
);
2930 h
->esym
.asym
.value
= 0;
2934 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2935 h
->root
.root
.root
.string
,
2938 einfo
->failed
= true;
2945 /* Search for and possibly create a got entry. */
2947 static struct alpha_elf_got_entry
*
2948 get_got_entry (abfd
, h
, r_type
, r_symndx
, r_addend
)
2950 struct alpha_elf_link_hash_entry
*h
;
2951 unsigned long r_type
, r_symndx
;
2954 struct alpha_elf_got_entry
*gotent
;
2955 struct alpha_elf_got_entry
**slot
;
2958 slot
= &h
->got_entries
;
2961 /* This is a local .got entry -- record for merge. */
2963 struct alpha_elf_got_entry
**local_got_entries
;
2965 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2966 if (!local_got_entries
)
2969 Elf_Internal_Shdr
*symtab_hdr
;
2971 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2972 size
= symtab_hdr
->sh_info
;
2973 size
*= sizeof (struct alpha_elf_got_entry
*);
2976 = (struct alpha_elf_got_entry
**) bfd_zalloc (abfd
, size
);
2977 if (!local_got_entries
)
2980 alpha_elf_tdata (abfd
)->local_got_entries
= local_got_entries
;
2983 slot
= &local_got_entries
[r_symndx
];
2986 for (gotent
= *slot
; gotent
; gotent
= gotent
->next
)
2987 if (gotent
->gotobj
== abfd
2988 && gotent
->reloc_type
== r_type
2989 && gotent
->addend
== r_addend
)
2997 amt
= sizeof (struct alpha_elf_got_entry
);
2998 gotent
= (struct alpha_elf_got_entry
*) bfd_alloc (abfd
, amt
);
3002 gotent
->gotobj
= abfd
;
3003 gotent
->addend
= r_addend
;
3004 gotent
->got_offset
= -1;
3005 gotent
->use_count
= 1;
3006 gotent
->reloc_type
= r_type
;
3007 gotent
->reloc_done
= 0;
3008 gotent
->reloc_xlated
= 0;
3010 gotent
->next
= *slot
;
3013 entry_size
= alpha_got_entry_size (r_type
);
3014 alpha_elf_tdata (abfd
)->total_got_size
+= entry_size
;
3016 alpha_elf_tdata(abfd
)->local_got_size
+= entry_size
;
3019 gotent
->use_count
+= 1;
3024 /* Handle dynamic relocations when doing an Alpha ELF link. */
3027 elf64_alpha_check_relocs (abfd
, info
, sec
, relocs
)
3029 struct bfd_link_info
*info
;
3031 const Elf_Internal_Rela
*relocs
;
3035 const char *rel_sec_name
;
3036 Elf_Internal_Shdr
*symtab_hdr
;
3037 struct alpha_elf_link_hash_entry
**sym_hashes
;
3038 const Elf_Internal_Rela
*rel
, *relend
;
3039 boolean got_created
;
3042 if (info
->relocateable
)
3045 dynobj
= elf_hash_table(info
)->dynobj
;
3047 elf_hash_table(info
)->dynobj
= dynobj
= abfd
;
3050 rel_sec_name
= NULL
;
3051 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
3052 sym_hashes
= alpha_elf_sym_hashes(abfd
);
3053 got_created
= false;
3055 relend
= relocs
+ sec
->reloc_count
;
3056 for (rel
= relocs
; rel
< relend
; ++rel
)
3064 unsigned long r_symndx
, r_type
;
3065 struct alpha_elf_link_hash_entry
*h
;
3066 unsigned int gotent_flags
;
3067 boolean maybe_dynamic
;
3071 r_symndx
= ELF64_R_SYM (rel
->r_info
);
3072 if (r_symndx
< symtab_hdr
->sh_info
)
3076 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3078 while (h
->root
.root
.type
== bfd_link_hash_indirect
3079 || h
->root
.root
.type
== bfd_link_hash_warning
)
3080 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3082 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
3085 /* We can only get preliminary data on whether a symbol is
3086 locally or externally defined, as not all of the input files
3087 have yet been processed. Do something with what we know, as
3088 this may help reduce memory usage and processing time later. */
3089 maybe_dynamic
= false;
3090 if (h
&& ((info
->shared
3091 && (!info
->symbolic
|| info
->allow_shlib_undefined
))
3092 || ! (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
3093 || h
->root
.root
.type
== bfd_link_hash_defweak
))
3094 maybe_dynamic
= true;
3098 r_type
= ELF64_R_TYPE (rel
->r_info
);
3099 addend
= rel
->r_addend
;
3103 case R_ALPHA_LITERAL
:
3104 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3106 /* Remember how this literal is used from its LITUSEs.
3107 This will be important when it comes to decide if we can
3108 create a .plt entry for a function symbol. */
3109 while (++rel
< relend
&& ELF64_R_TYPE (rel
->r_info
) == R_ALPHA_LITUSE
)
3110 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 5)
3111 gotent_flags
|= 1 << rel
->r_addend
;
3114 /* No LITUSEs -- presumably the address is used somehow. */
3115 if (gotent_flags
== 0)
3116 gotent_flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
3119 case R_ALPHA_GPDISP
:
3120 case R_ALPHA_GPREL16
:
3121 case R_ALPHA_GPREL32
:
3122 case R_ALPHA_GPRELHIGH
:
3123 case R_ALPHA_GPRELLOW
:
3128 case R_ALPHA_REFLONG
:
3129 case R_ALPHA_REFQUAD
:
3130 if (info
->shared
|| maybe_dynamic
)
3135 case R_ALPHA_TLSLDM
:
3136 case R_ALPHA_GOTDTPREL
:
3137 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3140 case R_ALPHA_GOTTPREL
:
3141 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3142 gotent_flags
= ALPHA_ELF_LINK_HASH_TLS_IE
;
3144 info
->flags
|= DF_STATIC_TLS
;
3147 case R_ALPHA_TPREL64
:
3148 if (info
->shared
|| maybe_dynamic
)
3151 info
->flags
|= DF_STATIC_TLS
;
3155 if (need
& NEED_GOT
)
3159 if (!elf64_alpha_create_got_section (abfd
, info
))
3162 /* Make sure the object's gotobj is set to itself so
3163 that we default to every object with its own .got.
3164 We'll merge .gots later once we've collected each
3166 alpha_elf_tdata(abfd
)->gotobj
= abfd
;
3172 if (need
& NEED_GOT_ENTRY
)
3174 struct alpha_elf_got_entry
*gotent
;
3176 gotent
= get_got_entry (abfd
, h
, r_type
, r_symndx
, addend
);
3182 gotent
->flags
|= gotent_flags
;
3185 gotent_flags
|= h
->flags
;
3186 h
->flags
= gotent_flags
;
3188 /* Make a guess as to whether a .plt entry is needed. */
3189 if ((gotent_flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
3190 && !(gotent_flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
))
3191 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
3193 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3198 if (need
& NEED_DYNREL
)
3200 if (rel_sec_name
== NULL
)
3202 rel_sec_name
= (bfd_elf_string_from_elf_section
3203 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
3204 elf_section_data(sec
)->rel_hdr
.sh_name
));
3205 if (rel_sec_name
== NULL
)
3208 BFD_ASSERT (strncmp (rel_sec_name
, ".rela", 5) == 0
3209 && strcmp (bfd_get_section_name (abfd
, sec
),
3210 rel_sec_name
+5) == 0);
3213 /* We need to create the section here now whether we eventually
3214 use it or not so that it gets mapped to an output section by
3215 the linker. If not used, we'll kill it in
3216 size_dynamic_sections. */
3219 sreloc
= bfd_get_section_by_name (dynobj
, rel_sec_name
);
3224 sreloc
= bfd_make_section (dynobj
, rel_sec_name
);
3225 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3226 | SEC_LINKER_CREATED
| SEC_READONLY
);
3227 if (sec
->flags
& SEC_ALLOC
)
3228 flags
|= SEC_ALLOC
| SEC_LOAD
;
3230 || !bfd_set_section_flags (dynobj
, sreloc
, flags
)
3231 || !bfd_set_section_alignment (dynobj
, sreloc
, 3))
3238 /* Since we havn't seen all of the input symbols yet, we
3239 don't know whether we'll actually need a dynamic relocation
3240 entry for this reloc. So make a record of it. Once we
3241 find out if this thing needs dynamic relocation we'll
3242 expand the relocation sections by the appropriate amount. */
3244 struct alpha_elf_reloc_entry
*rent
;
3246 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
3247 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
3252 amt
= sizeof (struct alpha_elf_reloc_entry
);
3253 rent
= (struct alpha_elf_reloc_entry
*) bfd_alloc (abfd
, amt
);
3257 rent
->srel
= sreloc
;
3258 rent
->rtype
= r_type
;
3260 rent
->reltext
= ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
3261 == (SEC_READONLY
| SEC_ALLOC
));
3263 rent
->next
= h
->reloc_entries
;
3264 h
->reloc_entries
= rent
;
3269 else if (info
->shared
)
3271 /* If this is a shared library, and the section is to be
3272 loaded into memory, we need a RELATIVE reloc. */
3273 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
3274 if ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
3275 == (SEC_READONLY
| SEC_ALLOC
))
3276 info
->flags
|= DF_TEXTREL
;
3284 /* Adjust a symbol defined by a dynamic object and referenced by a
3285 regular object. The current definition is in some section of the
3286 dynamic object, but we're not including those sections. We have to
3287 change the definition to something the rest of the link can
3291 elf64_alpha_adjust_dynamic_symbol (info
, h
)
3292 struct bfd_link_info
*info
;
3293 struct elf_link_hash_entry
*h
;
3297 struct alpha_elf_link_hash_entry
*ah
;
3299 dynobj
= elf_hash_table(info
)->dynobj
;
3300 ah
= (struct alpha_elf_link_hash_entry
*)h
;
3302 /* Now that we've seen all of the input symbols, finalize our decision
3303 about whether this symbol should get a .plt entry. */
3305 if (alpha_elf_dynamic_symbol_p (h
, info
)
3306 && ((h
->type
== STT_FUNC
3307 && !(ah
->flags
& ALPHA_ELF_LINK_HASH_LU_ADDR
))
3308 || (h
->type
== STT_NOTYPE
3309 && (ah
->flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
3310 && !(ah
->flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
)))
3311 /* Don't prevent otherwise valid programs from linking by attempting
3312 to create a new .got entry somewhere. A Correct Solution would be
3313 to add a new .got section to a new object file and let it be merged
3314 somewhere later. But for now don't bother. */
3317 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
3319 s
= bfd_get_section_by_name(dynobj
, ".plt");
3320 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
3323 /* The first bit of the .plt is reserved. */
3324 if (s
->_raw_size
== 0)
3325 s
->_raw_size
= PLT_HEADER_SIZE
;
3327 h
->plt
.offset
= s
->_raw_size
;
3328 s
->_raw_size
+= PLT_ENTRY_SIZE
;
3330 /* If this symbol is not defined in a regular file, and we are not
3331 generating a shared library, then set the symbol to the location
3332 in the .plt. This is required to make function pointers compare
3333 equal between the normal executable and the shared library. */
3335 && h
->root
.type
!= bfd_link_hash_defweak
)
3337 h
->root
.u
.def
.section
= s
;
3338 h
->root
.u
.def
.value
= h
->plt
.offset
;
3341 /* We also need a JMP_SLOT entry in the .rela.plt section. */
3342 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3343 BFD_ASSERT (s
!= NULL
);
3344 s
->_raw_size
+= sizeof (Elf64_External_Rela
);
3349 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3351 /* If this is a weak symbol, and there is a real definition, the
3352 processor independent code will have arranged for us to see the
3353 real definition first, and we can just use the same value. */
3354 if (h
->weakdef
!= NULL
)
3356 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
3357 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
3358 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
3359 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
3363 /* This is a reference to a symbol defined by a dynamic object which
3364 is not a function. The Alpha, since it uses .got entries for all
3365 symbols even in regular objects, does not need the hackery of a
3366 .dynbss section and COPY dynamic relocations. */
3371 /* Symbol versioning can create new symbols, and make our old symbols
3372 indirect to the new ones. Consolidate the got and reloc information
3373 in these situations. */
3376 elf64_alpha_merge_ind_symbols (hi
, dummy
)
3377 struct alpha_elf_link_hash_entry
*hi
;
3378 PTR dummy ATTRIBUTE_UNUSED
;
3380 struct alpha_elf_link_hash_entry
*hs
;
3382 if (hi
->root
.root
.type
!= bfd_link_hash_indirect
)
3386 hs
= (struct alpha_elf_link_hash_entry
*)hs
->root
.root
.u
.i
.link
;
3387 } while (hs
->root
.root
.type
== bfd_link_hash_indirect
);
3389 /* Merge the flags. Whee. */
3391 hs
->flags
|= hi
->flags
;
3393 /* Merge the .got entries. Cannibalize the old symbol's list in
3394 doing so, since we don't need it anymore. */
3396 if (hs
->got_entries
== NULL
)
3397 hs
->got_entries
= hi
->got_entries
;
3400 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
3402 gsh
= hs
->got_entries
;
3403 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
3406 for (gs
= gsh
; gs
; gs
= gs
->next
)
3407 if (gi
->gotobj
== gs
->gotobj
3408 && gi
->reloc_type
== gs
->reloc_type
3409 && gi
->addend
== gs
->addend
)
3411 gi
->use_count
+= gs
->use_count
;
3414 gi
->next
= hs
->got_entries
;
3415 hs
->got_entries
= gi
;
3419 hi
->got_entries
= NULL
;
3421 /* And similar for the reloc entries. */
3423 if (hs
->reloc_entries
== NULL
)
3424 hs
->reloc_entries
= hi
->reloc_entries
;
3427 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
3429 rsh
= hs
->reloc_entries
;
3430 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
3433 for (rs
= rsh
; rs
; rs
= rs
->next
)
3434 if (ri
->rtype
== rs
->rtype
)
3436 rs
->count
+= ri
->count
;
3439 ri
->next
= hs
->reloc_entries
;
3440 hs
->reloc_entries
= ri
;
3444 hi
->reloc_entries
= NULL
;
3449 /* Is it possible to merge two object file's .got tables? */
3452 elf64_alpha_can_merge_gots (a
, b
)
3455 int total
= alpha_elf_tdata (a
)->total_got_size
;
3458 /* Trivial quick fallout test. */
3459 if (total
+ alpha_elf_tdata (b
)->total_got_size
<= MAX_GOT_SIZE
)
3462 /* By their nature, local .got entries cannot be merged. */
3463 if ((total
+= alpha_elf_tdata (b
)->local_got_size
) > MAX_GOT_SIZE
)
3466 /* Failing the common trivial comparison, we must effectively
3467 perform the merge. Not actually performing the merge means that
3468 we don't have to store undo information in case we fail. */
3469 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3471 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
3472 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3475 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3476 for (i
= 0; i
< n
; ++i
)
3478 struct alpha_elf_got_entry
*ae
, *be
;
3479 struct alpha_elf_link_hash_entry
*h
;
3482 while (h
->root
.root
.type
== bfd_link_hash_indirect
3483 || h
->root
.root
.type
== bfd_link_hash_warning
)
3484 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3486 for (be
= h
->got_entries
; be
; be
= be
->next
)
3488 if (be
->use_count
== 0)
3490 if (be
->gotobj
!= b
)
3493 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
3495 && ae
->reloc_type
== be
->reloc_type
3496 && ae
->addend
== be
->addend
)
3499 total
+= alpha_got_entry_size (be
->reloc_type
);
3500 if (total
> MAX_GOT_SIZE
)
3510 /* Actually merge two .got tables. */
3513 elf64_alpha_merge_gots (a
, b
)
3516 int total
= alpha_elf_tdata (a
)->total_got_size
;
3519 /* Remember local expansion. */
3521 int e
= alpha_elf_tdata (b
)->local_got_size
;
3523 alpha_elf_tdata (a
)->local_got_size
+= e
;
3526 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3528 struct alpha_elf_got_entry
**local_got_entries
;
3529 struct alpha_elf_link_hash_entry
**hashes
;
3530 Elf_Internal_Shdr
*symtab_hdr
;
3533 /* Let the local .got entries know they are part of a new subsegment. */
3534 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
3535 if (local_got_entries
)
3537 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
3538 for (i
= 0; i
< n
; ++i
)
3540 struct alpha_elf_got_entry
*ent
;
3541 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
3546 /* Merge the global .got entries. */
3547 hashes
= alpha_elf_sym_hashes (bsub
);
3548 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3550 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3551 for (i
= 0; i
< n
; ++i
)
3553 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
3554 struct alpha_elf_link_hash_entry
*h
;
3557 while (h
->root
.root
.type
== bfd_link_hash_indirect
3558 || h
->root
.root
.type
== bfd_link_hash_warning
)
3559 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3561 start
= &h
->got_entries
;
3562 for (pbe
= start
, be
= *start
; be
; pbe
= &be
->next
, be
= be
->next
)
3564 if (be
->use_count
== 0)
3569 if (be
->gotobj
!= b
)
3572 for (ae
= *start
; ae
; ae
= ae
->next
)
3574 && ae
->reloc_type
== be
->reloc_type
3575 && ae
->addend
== be
->addend
)
3577 ae
->flags
|= be
->flags
;
3578 ae
->use_count
+= be
->use_count
;
3583 total
+= alpha_got_entry_size (be
->reloc_type
);
3589 alpha_elf_tdata (bsub
)->gotobj
= a
;
3591 alpha_elf_tdata (a
)->total_got_size
= total
;
3593 /* Merge the two in_got chains. */
3598 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
3601 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
3605 /* Calculate the offsets for the got entries. */
3608 elf64_alpha_calc_got_offsets_for_symbol (h
, arg
)
3609 struct alpha_elf_link_hash_entry
*h
;
3610 PTR arg ATTRIBUTE_UNUSED
;
3612 struct alpha_elf_got_entry
*gotent
;
3614 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3615 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3617 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3618 if (gotent
->use_count
> 0)
3621 = &alpha_elf_tdata (gotent
->gotobj
)->got
->_raw_size
;
3623 gotent
->got_offset
= *plge
;
3624 *plge
+= alpha_got_entry_size (gotent
->reloc_type
);
3631 elf64_alpha_calc_got_offsets (info
)
3632 struct bfd_link_info
*info
;
3634 bfd
*i
, *got_list
= alpha_elf_hash_table(info
)->got_list
;
3636 /* First, zero out the .got sizes, as we may be recalculating the
3637 .got after optimizing it. */
3638 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3639 alpha_elf_tdata(i
)->got
->_raw_size
= 0;
3641 /* Next, fill in the offsets for all the global entries. */
3642 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3643 elf64_alpha_calc_got_offsets_for_symbol
,
3646 /* Finally, fill in the offsets for the local entries. */
3647 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3649 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->_raw_size
;
3652 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3654 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3657 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3658 if (!local_got_entries
)
3661 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3662 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
3663 if (gotent
->use_count
> 0)
3665 gotent
->got_offset
= got_offset
;
3666 got_offset
+= alpha_got_entry_size (gotent
->reloc_type
);
3670 alpha_elf_tdata(i
)->got
->_raw_size
= got_offset
;
3671 alpha_elf_tdata(i
)->got
->_cooked_size
= got_offset
;
3675 /* Constructs the gots. */
3678 elf64_alpha_size_got_sections (info
)
3679 struct bfd_link_info
*info
;
3681 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
3682 int something_changed
= 0;
3684 got_list
= alpha_elf_hash_table (info
)->got_list
;
3686 /* On the first time through, pretend we have an existing got list
3687 consisting of all of the input files. */
3688 if (got_list
== NULL
)
3690 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
3692 bfd
*this_got
= alpha_elf_tdata (i
)->gotobj
;
3693 if (this_got
== NULL
)
3696 /* We are assuming no merging has yet ocurred. */
3697 BFD_ASSERT (this_got
== i
);
3699 if (alpha_elf_tdata (this_got
)->total_got_size
> MAX_GOT_SIZE
)
3701 /* Yikes! A single object file has too many entries. */
3702 (*_bfd_error_handler
)
3703 (_("%s: .got subsegment exceeds 64K (size %d)"),
3704 bfd_archive_filename (i
),
3705 alpha_elf_tdata (this_got
)->total_got_size
);
3709 if (got_list
== NULL
)
3710 got_list
= this_got
;
3712 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
3713 cur_got_obj
= this_got
;
3716 /* Strange degenerate case of no got references. */
3717 if (got_list
== NULL
)
3720 alpha_elf_hash_table (info
)->got_list
= got_list
;
3722 /* Force got offsets to be recalculated. */
3723 something_changed
= 1;
3726 cur_got_obj
= got_list
;
3727 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
3730 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
3732 elf64_alpha_merge_gots (cur_got_obj
, i
);
3733 i
= alpha_elf_tdata(i
)->got_link_next
;
3734 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
3735 something_changed
= 1;
3740 i
= alpha_elf_tdata(i
)->got_link_next
;
3744 /* Once the gots have been merged, fill in the got offsets for
3745 everything therein. */
3746 if (1 || something_changed
)
3747 elf64_alpha_calc_got_offsets (info
);
3752 /* Called from relax_section to rebuild the PLT in light of
3753 potential changes in the function's status. */
3756 elf64_alpha_size_plt_section (info
)
3757 struct bfd_link_info
*info
;
3759 asection
*splt
, *spltrel
;
3760 unsigned long entries
;
3763 dynobj
= elf_hash_table(info
)->dynobj
;
3764 splt
= bfd_get_section_by_name(dynobj
, ".plt");
3768 splt
->_raw_size
= 0;
3770 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3771 elf64_alpha_size_plt_section_1
, splt
);
3773 splt
->_cooked_size
= splt
->_raw_size
;
3775 /* Every plt entry requires a JMP_SLOT relocation. */
3776 spltrel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3777 if (splt
->_raw_size
)
3778 entries
= (splt
->_raw_size
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3781 spltrel
->_raw_size
= entries
* sizeof (Elf64_External_Rela
);
3782 spltrel
->_cooked_size
= spltrel
->_raw_size
;
3788 elf64_alpha_size_plt_section_1 (h
, data
)
3789 struct alpha_elf_link_hash_entry
*h
;
3792 asection
*splt
= (asection
*) data
;
3793 struct alpha_elf_got_entry
*gotent
;
3795 /* If we didn't need an entry before, we still don't. */
3796 if (!(h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
))
3799 /* There must still be a LITERAL got entry for the function. */
3800 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3801 if (gotent
->reloc_type
== R_ALPHA_LITERAL
3802 && gotent
->use_count
> 0)
3805 /* If there is, reset the PLT offset. If not, there's no longer
3806 a need for the PLT entry. */
3809 if (splt
->_raw_size
== 0)
3810 splt
->_raw_size
= PLT_HEADER_SIZE
;
3811 h
->root
.plt
.offset
= splt
->_raw_size
;
3812 splt
->_raw_size
+= PLT_ENTRY_SIZE
;
3816 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
3817 h
->root
.plt
.offset
= -1;
3824 elf64_alpha_always_size_sections (output_bfd
, info
)
3825 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3826 struct bfd_link_info
*info
;
3830 if (info
->relocateable
)
3833 /* First, take care of the indirect symbols created by versioning. */
3834 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3835 elf64_alpha_merge_ind_symbols
,
3838 if (!elf64_alpha_size_got_sections (info
))
3841 /* Allocate space for all of the .got subsections. */
3842 i
= alpha_elf_hash_table (info
)->got_list
;
3843 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3845 asection
*s
= alpha_elf_tdata(i
)->got
;
3846 if (s
->_raw_size
> 0)
3848 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->_raw_size
);
3849 if (s
->contents
== NULL
)
3857 /* The number of dynamic relocations required by a static relocation. */
3860 alpha_dynamic_entries_for_reloc (r_type
, dynamic
, shared
)
3861 int r_type
, dynamic
, shared
;
3865 /* May appear in GOT entries. */
3867 return (dynamic
? 2 : shared
? 1 : 0);
3868 case R_ALPHA_TLSLDM
:
3870 case R_ALPHA_LITERAL
:
3871 return dynamic
|| shared
;
3872 case R_ALPHA_GOTDTPREL
:
3873 case R_ALPHA_GOTTPREL
:
3876 /* May appear in data sections. */
3877 case R_ALPHA_REFLONG
:
3878 case R_ALPHA_REFQUAD
:
3879 return dynamic
|| shared
;
3880 case R_ALPHA_SREL64
:
3881 case R_ALPHA_TPREL64
:
3884 /* Everything else is illegal. We'll issue an error during
3885 relocate_section. */
3891 /* Work out the sizes of the dynamic relocation entries. */
3894 elf64_alpha_calc_dynrel_sizes (h
, info
)
3895 struct alpha_elf_link_hash_entry
*h
;
3896 struct bfd_link_info
*info
;
3899 struct alpha_elf_reloc_entry
*relent
;
3900 unsigned long entries
;
3902 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3903 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3905 /* If the symbol was defined as a common symbol in a regular object
3906 file, and there was no definition in any dynamic object, then the
3907 linker will have allocated space for the symbol in a common
3908 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3909 set. This is done for dynamic symbols in
3910 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3911 symbols, somehow. */
3912 if (((h
->root
.elf_link_hash_flags
3913 & (ELF_LINK_HASH_DEF_REGULAR
3914 | ELF_LINK_HASH_REF_REGULAR
3915 | ELF_LINK_HASH_DEF_DYNAMIC
))
3916 == ELF_LINK_HASH_REF_REGULAR
)
3917 && (h
->root
.root
.type
== bfd_link_hash_defined
3918 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3919 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3920 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3922 /* If the symbol is dynamic, we'll need all the relocations in their
3923 natural form. If this is a shared object, and it has been forced
3924 local, we'll need the same number of RELATIVE relocations. */
3926 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3928 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
3930 entries
= alpha_dynamic_entries_for_reloc (relent
->rtype
, dynamic
,
3934 relent
->srel
->_raw_size
+=
3935 entries
* sizeof (Elf64_External_Rela
) * relent
->count
;
3936 if (relent
->reltext
)
3937 info
->flags
|= DT_TEXTREL
;
3944 /* Set the sizes of the dynamic relocation sections. */
3947 elf64_alpha_size_rela_got_section (info
)
3948 struct bfd_link_info
*info
;
3950 unsigned long entries
;
3954 /* Shared libraries often require RELATIVE relocs, and some relocs
3955 require attention for the main application as well. */
3958 for (i
= alpha_elf_hash_table(info
)->got_list
;
3959 i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3963 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3965 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3968 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3969 if (!local_got_entries
)
3972 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3973 for (gotent
= local_got_entries
[k
];
3974 gotent
; gotent
= gotent
->next
)
3975 if (gotent
->use_count
> 0)
3976 entries
+= (alpha_dynamic_entries_for_reloc
3977 (gotent
->reloc_type
, 0, info
->shared
));
3981 dynobj
= elf_hash_table(info
)->dynobj
;
3982 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3985 BFD_ASSERT (entries
== 0);
3988 srel
->_raw_size
= sizeof (Elf64_External_Rela
) * entries
;
3990 /* Now do the non-local symbols. */
3991 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3992 elf64_alpha_size_rela_got_1
, info
);
3994 srel
->_cooked_size
= srel
->_raw_size
;
3999 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
4003 elf64_alpha_size_rela_got_1 (h
, info
)
4004 struct alpha_elf_link_hash_entry
*h
;
4005 struct bfd_link_info
*info
;
4008 struct alpha_elf_got_entry
*gotent
;
4009 unsigned long entries
;
4011 if (h
->root
.root
.type
== bfd_link_hash_warning
)
4012 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
4014 /* If the symbol is dynamic, we'll need all the relocations in their
4015 natural form. If this is a shared object, and it has been forced
4016 local, we'll need the same number of RELATIVE relocations. */
4018 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
4021 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
4022 if (gotent
->use_count
> 0)
4023 entries
+= alpha_dynamic_entries_for_reloc (gotent
->reloc_type
,
4024 dynamic
, info
->shared
);
4026 /* If we are using a .plt entry, subtract one, as the first
4027 reference uses a .rela.plt entry instead. */
4028 if (h
->root
.plt
.offset
!= MINUS_ONE
)
4033 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
4034 asection
*srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4035 BFD_ASSERT (srel
!= NULL
);
4036 srel
->_raw_size
+= sizeof (Elf64_External_Rela
) * entries
;
4042 /* Set the sizes of the dynamic sections. */
4045 elf64_alpha_size_dynamic_sections (output_bfd
, info
)
4046 bfd
*output_bfd ATTRIBUTE_UNUSED
;
4047 struct bfd_link_info
*info
;
4053 dynobj
= elf_hash_table(info
)->dynobj
;
4054 BFD_ASSERT(dynobj
!= NULL
);
4056 if (elf_hash_table (info
)->dynamic_sections_created
)
4058 /* Set the contents of the .interp section to the interpreter. */
4061 s
= bfd_get_section_by_name (dynobj
, ".interp");
4062 BFD_ASSERT (s
!= NULL
);
4063 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4064 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
4067 /* Now that we've seen all of the input files, we can decide which
4068 symbols need dynamic relocation entries and which don't. We've
4069 collected information in check_relocs that we can now apply to
4070 size the dynamic relocation sections. */
4071 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
4072 elf64_alpha_calc_dynrel_sizes
, info
);
4074 elf64_alpha_size_rela_got_section (info
);
4076 /* else we're not dynamic and by definition we don't need such things. */
4078 /* The check_relocs and adjust_dynamic_symbol entry points have
4079 determined the sizes of the various dynamic sections. Allocate
4082 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
4087 if (!(s
->flags
& SEC_LINKER_CREATED
))
4090 /* It's OK to base decisions on the section name, because none
4091 of the dynobj section names depend upon the input files. */
4092 name
= bfd_get_section_name (dynobj
, s
);
4094 /* If we don't need this section, strip it from the output file.
4095 This is to handle .rela.bss and .rela.plt. We must create it
4096 in create_dynamic_sections, because it must be created before
4097 the linker maps input sections to output sections. The
4098 linker does that before adjust_dynamic_symbol is called, and
4099 it is that function which decides whether anything needs to
4100 go into these sections. */
4104 if (strncmp (name
, ".rela", 5) == 0)
4106 strip
= (s
->_raw_size
== 0);
4110 if (strcmp(name
, ".rela.plt") == 0)
4113 /* We use the reloc_count field as a counter if we need
4114 to copy relocs into the output file. */
4118 else if (strcmp (name
, ".plt") != 0)
4120 /* It's not one of our dynamic sections, so don't allocate space. */
4125 _bfd_strip_section_from_output (info
, s
);
4128 /* Allocate memory for the section contents. */
4129 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
4130 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
4135 if (elf_hash_table (info
)->dynamic_sections_created
)
4137 /* Add some entries to the .dynamic section. We fill in the
4138 values later, in elf64_alpha_finish_dynamic_sections, but we
4139 must add the entries now so that we get the correct size for
4140 the .dynamic section. The DT_DEBUG entry is filled in by the
4141 dynamic linker and used by the debugger. */
4142 #define add_dynamic_entry(TAG, VAL) \
4143 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
4147 if (!add_dynamic_entry (DT_DEBUG
, 0))
4151 if (!add_dynamic_entry (DT_PLTGOT
, 0))
4156 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
4157 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
4158 || !add_dynamic_entry (DT_JMPREL
, 0))
4162 if (!add_dynamic_entry (DT_RELA
, 0)
4163 || !add_dynamic_entry (DT_RELASZ
, 0)
4164 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
4167 if (info
->flags
& DF_TEXTREL
)
4169 if (!add_dynamic_entry (DT_TEXTREL
, 0))
4173 #undef add_dynamic_entry
4178 /* Relocate an Alpha ELF section for a relocatable link.
4180 We don't have to change anything unless the reloc is against a section
4181 symbol, in which case we have to adjust according to where the section
4182 symbol winds up in the output section. */
4185 elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
, input_section
,
4186 contents
, relocs
, local_syms
, local_sections
)
4187 bfd
*output_bfd ATTRIBUTE_UNUSED
;
4188 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4190 asection
*input_section
;
4191 bfd_byte
*contents ATTRIBUTE_UNUSED
;
4192 Elf_Internal_Rela
*relocs
;
4193 Elf_Internal_Sym
*local_syms
;
4194 asection
**local_sections
;
4196 unsigned long symtab_hdr_sh_info
;
4197 Elf_Internal_Rela
*rel
;
4198 Elf_Internal_Rela
*relend
;
4199 boolean ret_val
= true;
4201 symtab_hdr_sh_info
= elf_tdata (input_bfd
)->symtab_hdr
.sh_info
;
4203 relend
= relocs
+ input_section
->reloc_count
;
4204 for (rel
= relocs
; rel
< relend
; rel
++)
4206 unsigned long r_symndx
;
4207 Elf_Internal_Sym
*sym
;
4209 unsigned long r_type
;
4211 r_type
= ELF64_R_TYPE(rel
->r_info
);
4212 if (r_type
>= R_ALPHA_max
)
4214 (*_bfd_error_handler
)
4215 (_("%s: unknown relocation type %d"),
4216 bfd_archive_filename (input_bfd
), (int)r_type
);
4217 bfd_set_error (bfd_error_bad_value
);
4222 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4224 /* The symbol associated with GPDISP and LITUSE is
4225 immaterial. Only the addend is significant. */
4226 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
4229 if (r_symndx
< symtab_hdr_sh_info
)
4231 sym
= local_syms
+ r_symndx
;
4232 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
4234 sec
= local_sections
[r_symndx
];
4235 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
4243 /* Relocate an Alpha ELF section. */
4246 elf64_alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
4247 contents
, relocs
, local_syms
, local_sections
)
4249 struct bfd_link_info
*info
;
4251 asection
*input_section
;
4253 Elf_Internal_Rela
*relocs
;
4254 Elf_Internal_Sym
*local_syms
;
4255 asection
**local_sections
;
4257 Elf_Internal_Shdr
*symtab_hdr
;
4258 Elf_Internal_Rela
*rel
;
4259 Elf_Internal_Rela
*relend
;
4260 struct elf_link_tls_segment
*tls_segment
;
4261 asection
*sgot
, *srel
, *srelgot
;
4262 bfd
*dynobj
, *gotobj
;
4263 bfd_vma gp
, tp_base
, dtp_base
;
4264 struct alpha_elf_got_entry
**local_got_entries
;
4266 const char *section_name
;
4268 /* Handle relocatable links with a smaller loop. */
4269 if (info
->relocateable
)
4270 return elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
,
4271 input_section
, contents
, relocs
,
4272 local_syms
, local_sections
);
4274 /* This is a final link. */
4278 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4280 dynobj
= elf_hash_table (info
)->dynobj
;
4282 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
4286 section_name
= (bfd_elf_string_from_elf_section
4287 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
4288 elf_section_data(input_section
)->rel_hdr
.sh_name
));
4289 BFD_ASSERT(section_name
!= NULL
);
4290 srel
= bfd_get_section_by_name (dynobj
, section_name
);
4292 /* Find the gp value for this input bfd. */
4293 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
4296 sgot
= alpha_elf_tdata (gotobj
)->got
;
4297 gp
= _bfd_get_gp_value (gotobj
);
4300 gp
= (sgot
->output_section
->vma
4301 + sgot
->output_offset
4303 _bfd_set_gp_value (gotobj
, gp
);
4312 local_got_entries
= alpha_elf_tdata(input_bfd
)->local_got_entries
;
4314 tls_segment
= elf_hash_table (info
)->tls_segment
;
4317 dtp_base
= alpha_get_dtprel_base (tls_segment
);
4318 tp_base
= alpha_get_tprel_base (tls_segment
);
4321 dtp_base
= tp_base
= 0;
4323 relend
= relocs
+ input_section
->reloc_count
;
4324 for (rel
= relocs
; rel
< relend
; rel
++)
4326 struct alpha_elf_link_hash_entry
*h
= NULL
;
4327 struct alpha_elf_got_entry
*gotent
;
4328 bfd_reloc_status_type r
;
4329 reloc_howto_type
*howto
;
4330 unsigned long r_symndx
;
4331 Elf_Internal_Sym
*sym
= NULL
;
4332 asection
*sec
= NULL
;
4335 boolean dynamic_symbol_p
;
4336 boolean undef_weak_ref
= false;
4337 unsigned long r_type
;
4339 r_type
= ELF64_R_TYPE(rel
->r_info
);
4340 if (r_type
>= R_ALPHA_max
)
4342 (*_bfd_error_handler
)
4343 (_("%s: unknown relocation type %d"),
4344 bfd_archive_filename (input_bfd
), (int)r_type
);
4345 bfd_set_error (bfd_error_bad_value
);
4350 howto
= elf64_alpha_howto_table
+ r_type
;
4351 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4353 if (r_symndx
< symtab_hdr
->sh_info
)
4355 sym
= local_syms
+ r_symndx
;
4356 sec
= local_sections
[r_symndx
];
4357 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
4359 if (local_got_entries
)
4360 gotent
= local_got_entries
[r_symndx
];
4364 /* Need to adjust local GOT entries' addends for SEC_MERGE
4365 unless it has been done already. */
4366 if ((sec
->flags
& SEC_MERGE
)
4367 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
4368 && (elf_section_data (sec
)->sec_info_type
4369 == ELF_INFO_TYPE_MERGE
)
4371 && !gotent
->reloc_xlated
)
4373 struct alpha_elf_got_entry
*ent
;
4376 for (ent
= gotent
; ent
; ent
= ent
->next
)
4378 ent
->reloc_xlated
= 1;
4379 if (ent
->use_count
== 0)
4383 _bfd_merged_section_offset (output_bfd
, &msec
,
4384 elf_section_data (sec
)->
4386 sym
->st_value
+ ent
->addend
,
4388 ent
->addend
-= sym
->st_value
;
4389 ent
->addend
+= msec
->output_section
->vma
4390 + msec
->output_offset
4391 - sec
->output_section
->vma
4392 - sec
->output_offset
;
4396 dynamic_symbol_p
= false;
4400 h
= alpha_elf_sym_hashes (input_bfd
)[r_symndx
- symtab_hdr
->sh_info
];
4402 while (h
->root
.root
.type
== bfd_link_hash_indirect
4403 || h
->root
.root
.type
== bfd_link_hash_warning
)
4404 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
4407 if (h
->root
.root
.type
== bfd_link_hash_defined
4408 || h
->root
.root
.type
== bfd_link_hash_defweak
)
4410 sec
= h
->root
.root
.u
.def
.section
;
4412 /* Detect the cases that sym_sec->output_section is
4413 expected to be NULL -- all cases in which the symbol
4414 is defined in another shared module. This includes
4415 PLT relocs for which we've created a PLT entry and
4416 other relocs for which we're prepared to create
4417 dynamic relocations. */
4418 /* ??? Just accept it NULL and continue. */
4420 if (sec
->output_section
!= NULL
)
4421 value
= (h
->root
.root
.u
.def
.value
4422 + sec
->output_section
->vma
4423 + sec
->output_offset
);
4425 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
4426 undef_weak_ref
= true;
4427 else if (info
->shared
4428 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
4429 && !info
->no_undefined
4430 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
4434 if (!((*info
->callbacks
->undefined_symbol
)
4435 (info
, h
->root
.root
.root
.string
, input_bfd
,
4436 input_section
, rel
->r_offset
,
4437 (!info
->shared
|| info
->no_undefined
4438 || ELF_ST_VISIBILITY (h
->root
.other
)))))
4444 dynamic_symbol_p
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
4445 gotent
= h
->got_entries
;
4448 addend
= rel
->r_addend
;
4451 /* Search for the proper got entry. */
4452 for (; gotent
; gotent
= gotent
->next
)
4453 if (gotent
->gotobj
== gotobj
4454 && gotent
->reloc_type
== r_type
4455 && gotent
->addend
== addend
)
4460 case R_ALPHA_GPDISP
:
4462 bfd_byte
*p_ldah
, *p_lda
;
4464 BFD_ASSERT(gp
!= 0);
4466 value
= (input_section
->output_section
->vma
4467 + input_section
->output_offset
4470 p_ldah
= contents
+ rel
->r_offset
;
4471 p_lda
= p_ldah
+ rel
->r_addend
;
4473 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- value
,
4478 case R_ALPHA_LITERAL
:
4479 BFD_ASSERT(sgot
!= NULL
);
4480 BFD_ASSERT(gp
!= 0);
4481 BFD_ASSERT(gotent
!= NULL
);
4482 BFD_ASSERT(gotent
->use_count
>= 1);
4484 if (!gotent
->reloc_done
)
4486 gotent
->reloc_done
= 1;
4488 bfd_put_64 (output_bfd
, value
,
4489 sgot
->contents
+ gotent
->got_offset
);
4491 /* If the symbol has been forced local, output a
4492 RELATIVE reloc, otherwise it will be handled in
4493 finish_dynamic_symbol. */
4494 if (info
->shared
&& !dynamic_symbol_p
)
4496 Elf_Internal_Rela outrel
;
4498 BFD_ASSERT(srelgot
!= NULL
);
4500 outrel
.r_offset
= (sgot
->output_section
->vma
4501 + sgot
->output_offset
4502 + gotent
->got_offset
);
4503 outrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_RELATIVE
);
4504 outrel
.r_addend
= value
;
4506 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4507 ((Elf64_External_Rela
*)
4509 + srelgot
->reloc_count
++);
4510 BFD_ASSERT (sizeof (Elf64_External_Rela
)
4511 * srelgot
->reloc_count
4512 <= srelgot
->_cooked_size
);
4516 value
= (sgot
->output_section
->vma
4517 + sgot
->output_offset
4518 + gotent
->got_offset
);
4522 case R_ALPHA_GPREL16
:
4523 case R_ALPHA_GPREL32
:
4524 case R_ALPHA_GPRELLOW
:
4525 if (dynamic_symbol_p
)
4527 (*_bfd_error_handler
)
4528 (_("%s: gp-relative relocation against dynamic symbol %s"),
4529 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4532 BFD_ASSERT(gp
!= 0);
4536 case R_ALPHA_GPRELHIGH
:
4537 if (dynamic_symbol_p
)
4539 (*_bfd_error_handler
)
4540 (_("%s: gp-relative relocation against dynamic symbol %s"),
4541 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4544 BFD_ASSERT(gp
!= 0);
4546 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4550 /* A call to a dynamic symbol is definitely out of range of
4551 the 16-bit displacement. Don't bother writing anything. */
4552 if (dynamic_symbol_p
)
4557 /* The regular PC-relative stuff measures from the start of
4558 the instruction rather than the end. */
4562 case R_ALPHA_BRADDR
:
4563 if (dynamic_symbol_p
)
4565 (*_bfd_error_handler
)
4566 (_("%s: pc-relative relocation against dynamic symbol %s"),
4567 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4570 /* The regular PC-relative stuff measures from the start of
4571 the instruction rather than the end. */
4580 /* The regular PC-relative stuff measures from the start of
4581 the instruction rather than the end. */
4584 /* The source and destination gp must be the same. Note that
4585 the source will always have an assigned gp, since we forced
4586 one in check_relocs, but that the destination may not, as
4587 it might not have had any relocations at all. Also take
4588 care not to crash if H is an undefined symbol. */
4589 if (h
!= NULL
&& sec
!= NULL
4590 && alpha_elf_tdata (sec
->owner
)->gotobj
4591 && gotobj
!= alpha_elf_tdata (sec
->owner
)->gotobj
)
4593 (*_bfd_error_handler
)
4594 (_("%s: change in gp: BRSGP %s"),
4595 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4599 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4601 other
= h
->root
.other
;
4603 other
= sym
->st_other
;
4604 switch (other
& STO_ALPHA_STD_GPLOAD
)
4606 case STO_ALPHA_NOPV
:
4608 case STO_ALPHA_STD_GPLOAD
:
4613 name
= h
->root
.root
.root
.string
;
4616 name
= (bfd_elf_string_from_elf_section
4617 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4619 name
= _("<unknown>");
4620 else if (name
[0] == 0)
4621 name
= bfd_section_name (input_bfd
, sec
);
4623 (*_bfd_error_handler
)
4624 (_("%s: !samegp reloc against symbol without .prologue: %s"),
4625 bfd_archive_filename (input_bfd
), name
);
4633 case R_ALPHA_REFLONG
:
4634 case R_ALPHA_REFQUAD
:
4635 case R_ALPHA_DTPREL64
:
4636 case R_ALPHA_TPREL64
:
4638 Elf_Internal_Rela outrel
;
4640 /* Careful here to remember RELATIVE relocations for global
4641 variables for symbolic shared objects. */
4643 if (dynamic_symbol_p
)
4645 BFD_ASSERT(h
->root
.dynindx
!= -1);
4646 outrel
.r_info
= ELF64_R_INFO (h
->root
.dynindx
, r_type
);
4647 outrel
.r_addend
= addend
;
4648 addend
= 0, value
= 0;
4650 else if (r_type
== R_ALPHA_DTPREL64
)
4652 BFD_ASSERT(tls_segment
!= NULL
);
4656 else if (r_type
== R_ALPHA_TPREL64
)
4658 BFD_ASSERT(tls_segment
!= NULL
);
4662 else if (info
->shared
4664 && (input_section
->flags
& SEC_ALLOC
))
4666 if (r_type
== R_ALPHA_REFLONG
)
4668 (*_bfd_error_handler
)
4669 (_("%s: unhandled dynamic relocation against %s"),
4670 bfd_archive_filename (input_bfd
),
4671 h
->root
.root
.root
.string
);
4674 outrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_RELATIVE
);
4675 outrel
.r_addend
= value
;
4680 BFD_ASSERT(srel
!= NULL
);
4683 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4685 if ((outrel
.r_offset
| 1) != (bfd_vma
) -1)
4686 outrel
.r_offset
+= (input_section
->output_section
->vma
4687 + input_section
->output_offset
);
4689 memset (&outrel
, 0, sizeof outrel
);
4691 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4692 ((Elf64_External_Rela
*)
4694 + srel
->reloc_count
++);
4695 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
4696 <= srel
->_cooked_size
);
4700 case R_ALPHA_SREL16
:
4701 case R_ALPHA_SREL32
:
4702 case R_ALPHA_SREL64
:
4703 if (dynamic_symbol_p
)
4705 (*_bfd_error_handler
)
4706 (_("%s: pc-relative relocation against dynamic symbol %s"),
4707 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4711 /* ??? .eh_frame references to discarded sections will be smashed
4712 to relocations against SHN_UNDEF. The .eh_frame format allows
4713 NULL to be encoded as 0 in any format, so this works here. */
4715 howto
= (elf64_alpha_howto_table
4716 + (r_type
- R_ALPHA_SREL32
+ R_ALPHA_REFLONG
));
4719 case R_ALPHA_TLSLDM
:
4720 /* Ignore the symbol for the relocation. The result is always
4721 the current module. */
4722 dynamic_symbol_p
= 0;
4726 if (!gotent
->reloc_done
)
4728 gotent
->reloc_done
= 1;
4730 /* Note that the module index for the main program is 1. */
4731 bfd_put_64 (output_bfd
, !info
->shared
&& !dynamic_symbol_p
,
4732 sgot
->contents
+ gotent
->got_offset
);
4734 /* If the symbol has been forced local, output a
4735 DTPMOD64 reloc, otherwise it will be handled in
4736 finish_dynamic_symbol. */
4737 if (info
->shared
&& !dynamic_symbol_p
)
4739 Elf_Internal_Rela outrel
;
4741 BFD_ASSERT(srelgot
!= NULL
);
4743 outrel
.r_offset
= (sgot
->output_section
->vma
4744 + sgot
->output_offset
4745 + gotent
->got_offset
);
4746 /* ??? Proper dynindx here. */
4747 outrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_DTPMOD64
);
4748 outrel
.r_addend
= 0;
4750 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4751 ((Elf64_External_Rela
*)
4753 + srelgot
->reloc_count
++);
4754 BFD_ASSERT (sizeof (Elf64_External_Rela
)
4755 * srelgot
->reloc_count
4756 <= srelgot
->_cooked_size
);
4759 if (dynamic_symbol_p
|| r_type
== R_ALPHA_TLSLDM
)
4763 BFD_ASSERT(tls_segment
!= NULL
);
4766 bfd_put_64 (output_bfd
, value
,
4767 sgot
->contents
+ gotent
->got_offset
+ 8);
4770 value
= (sgot
->output_section
->vma
4771 + sgot
->output_offset
4772 + gotent
->got_offset
);
4776 case R_ALPHA_DTPRELHI
:
4777 case R_ALPHA_DTPRELLO
:
4778 case R_ALPHA_DTPREL16
:
4779 if (dynamic_symbol_p
)
4781 (*_bfd_error_handler
)
4782 (_("%s: dtp-relative relocation against dynamic symbol %s"),
4783 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4786 BFD_ASSERT(tls_segment
!= NULL
);
4788 if (r_type
== R_ALPHA_DTPRELHI
)
4789 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4792 case R_ALPHA_TPRELHI
:
4793 case R_ALPHA_TPRELLO
:
4794 case R_ALPHA_TPREL16
:
4797 (*_bfd_error_handler
)
4798 (_("%s: TLS local exec code cannot be linked into shared objects"),
4799 bfd_archive_filename (input_bfd
));
4802 else if (dynamic_symbol_p
)
4804 (*_bfd_error_handler
)
4805 (_("%s: tp-relative relocation against dynamic symbol %s"),
4806 bfd_archive_filename (input_bfd
), h
->root
.root
.root
.string
);
4809 BFD_ASSERT(tls_segment
!= NULL
);
4811 if (r_type
== R_ALPHA_TPRELHI
)
4812 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4815 case R_ALPHA_GOTDTPREL
:
4816 case R_ALPHA_GOTTPREL
:
4817 BFD_ASSERT(sgot
!= NULL
);
4818 BFD_ASSERT(gp
!= 0);
4819 BFD_ASSERT(gotent
!= NULL
);
4820 BFD_ASSERT(gotent
->use_count
>= 1);
4822 if (!gotent
->reloc_done
)
4824 gotent
->reloc_done
= 1;
4826 if (dynamic_symbol_p
)
4830 BFD_ASSERT(tls_segment
!= NULL
);
4831 value
-= (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
4833 bfd_put_64 (output_bfd
, value
,
4834 sgot
->contents
+ gotent
->got_offset
);
4837 value
= (sgot
->output_section
->vma
4838 + sgot
->output_offset
4839 + gotent
->got_offset
);
4845 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4846 contents
, rel
->r_offset
, value
, 0);
4855 case bfd_reloc_overflow
:
4859 /* Don't warn if the overflow is due to pc relative reloc
4860 against discarded section. Section optimization code should
4863 if (r_symndx
< symtab_hdr
->sh_info
4864 && sec
!= NULL
&& howto
->pc_relative
4865 && elf_discarded_section (sec
))
4869 name
= h
->root
.root
.root
.string
;
4872 name
= (bfd_elf_string_from_elf_section
4873 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4877 name
= bfd_section_name (input_bfd
, sec
);
4879 if (! ((*info
->callbacks
->reloc_overflow
)
4880 (info
, name
, howto
->name
, (bfd_vma
) 0,
4881 input_bfd
, input_section
, rel
->r_offset
)))
4887 case bfd_reloc_outofrange
:
4895 /* Finish up dynamic symbol handling. We set the contents of various
4896 dynamic sections here. */
4899 elf64_alpha_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4901 struct bfd_link_info
*info
;
4902 struct elf_link_hash_entry
*h
;
4903 Elf_Internal_Sym
*sym
;
4905 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
4907 if (h
->plt
.offset
!= MINUS_ONE
)
4909 /* Fill in the .plt entry for this symbol. */
4910 asection
*splt
, *sgot
, *srel
;
4911 Elf_Internal_Rela outrel
;
4912 bfd_vma got_addr
, plt_addr
;
4914 struct alpha_elf_got_entry
*gotent
;
4916 BFD_ASSERT (h
->dynindx
!= -1);
4918 /* The first .got entry will be updated by the .plt with the
4919 address of the target function. */
4920 gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4921 BFD_ASSERT (gotent
&& gotent
->addend
== 0);
4923 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4924 BFD_ASSERT (splt
!= NULL
);
4925 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4926 BFD_ASSERT (srel
!= NULL
);
4927 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4928 BFD_ASSERT (sgot
!= NULL
);
4930 got_addr
= (sgot
->output_section
->vma
4931 + sgot
->output_offset
4932 + gotent
->got_offset
);
4933 plt_addr
= (splt
->output_section
->vma
4934 + splt
->output_offset
4937 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
4939 /* Fill in the entry in the procedure linkage table. */
4941 bfd_vma insn1
, insn2
, insn3
;
4943 insn1
= PLT_ENTRY_WORD1
| ((-(h
->plt
.offset
+ 4) >> 2) & 0x1fffff);
4944 insn2
= PLT_ENTRY_WORD2
;
4945 insn3
= PLT_ENTRY_WORD3
;
4947 bfd_put_32 (output_bfd
, insn1
, splt
->contents
+ h
->plt
.offset
);
4948 bfd_put_32 (output_bfd
, insn2
, splt
->contents
+ h
->plt
.offset
+ 4);
4949 bfd_put_32 (output_bfd
, insn3
, splt
->contents
+ h
->plt
.offset
+ 8);
4952 /* Fill in the entry in the .rela.plt section. */
4953 outrel
.r_offset
= got_addr
;
4954 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
4955 outrel
.r_addend
= 0;
4957 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4958 ((Elf64_External_Rela
*)srel
->contents
4961 if (!(h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
4963 /* Mark the symbol as undefined, rather than as defined in the
4964 .plt section. Leave the value alone. */
4965 sym
->st_shndx
= SHN_UNDEF
;
4968 /* Fill in the entries in the .got. */
4969 bfd_put_64 (output_bfd
, plt_addr
, sgot
->contents
+ gotent
->got_offset
);
4971 /* Subsequent .got entries will continue to bounce through the .plt. */
4974 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4975 BFD_ASSERT (! info
->shared
|| srel
!= NULL
);
4977 gotent
= gotent
->next
;
4980 sgot
= alpha_elf_tdata(gotent
->gotobj
)->got
;
4981 BFD_ASSERT(sgot
!= NULL
);
4982 BFD_ASSERT(gotent
->addend
== 0);
4984 bfd_put_64 (output_bfd
, plt_addr
,
4985 sgot
->contents
+ gotent
->got_offset
);
4989 outrel
.r_offset
= (sgot
->output_section
->vma
4990 + sgot
->output_offset
4991 + gotent
->got_offset
);
4992 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
4993 outrel
.r_addend
= plt_addr
;
4995 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
4996 ((Elf64_External_Rela
*)
4998 + srel
->reloc_count
++);
4999 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
5000 <= srel
->_cooked_size
);
5003 gotent
= gotent
->next
;
5005 while (gotent
!= NULL
);
5008 else if (alpha_elf_dynamic_symbol_p (h
, info
))
5010 /* Fill in the dynamic relocations for this symbol's .got entries. */
5012 Elf_Internal_Rela outrel
;
5013 struct alpha_elf_got_entry
*gotent
;
5015 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
5016 BFD_ASSERT (srel
!= NULL
);
5018 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
5020 gotent
= gotent
->next
)
5025 if (gotent
->use_count
== 0)
5028 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
5029 outrel
.r_offset
= (sgot
->output_section
->vma
5030 + sgot
->output_offset
5031 + gotent
->got_offset
);
5033 r_type
= gotent
->reloc_type
;
5036 case R_ALPHA_LITERAL
:
5037 r_type
= R_ALPHA_GLOB_DAT
;
5040 r_type
= R_ALPHA_DTPMOD64
;
5042 case R_ALPHA_GOTDTPREL
:
5043 r_type
= R_ALPHA_DTPREL64
;
5045 case R_ALPHA_GOTTPREL
:
5046 r_type
= R_ALPHA_TPREL64
;
5048 case R_ALPHA_TLSLDM
:
5053 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
5054 outrel
.r_addend
= gotent
->addend
;
5056 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
5057 ((Elf64_External_Rela
*)srel
->contents
5058 + srel
->reloc_count
++));
5060 if (gotent
->reloc_type
== R_ALPHA_TLSGD
)
5062 outrel
.r_offset
+= 8;
5063 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_ALPHA_DTPREL64
);
5065 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
5066 ((Elf64_External_Rela
*)srel
->contents
5067 + srel
->reloc_count
++));
5070 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
5071 <= srel
->_cooked_size
);
5075 /* Mark some specially defined symbols as absolute. */
5076 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5077 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
5078 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
5079 sym
->st_shndx
= SHN_ABS
;
5084 /* Finish up the dynamic sections. */
5087 elf64_alpha_finish_dynamic_sections (output_bfd
, info
)
5089 struct bfd_link_info
*info
;
5094 dynobj
= elf_hash_table (info
)->dynobj
;
5095 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5097 if (elf_hash_table (info
)->dynamic_sections_created
)
5100 Elf64_External_Dyn
*dyncon
, *dynconend
;
5102 splt
= bfd_get_section_by_name (dynobj
, ".plt");
5103 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
5105 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
5106 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
5107 for (; dyncon
< dynconend
; dyncon
++)
5109 Elf_Internal_Dyn dyn
;
5113 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5128 /* My interpretation of the TIS v1.1 ELF document indicates
5129 that RELASZ should not include JMPREL. This is not what
5130 the rest of the BFD does. It is, however, what the
5131 glibc ld.so wants. Do this fixup here until we found
5132 out who is right. */
5133 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
5137 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
5142 s
= bfd_get_section_by_name (output_bfd
, name
);
5143 dyn
.d_un
.d_ptr
= (s
? s
->vma
: 0);
5147 s
= bfd_get_section_by_name (output_bfd
, name
);
5149 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
5153 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5156 /* Initialize the PLT0 entry */
5157 if (splt
->_raw_size
> 0)
5159 bfd_put_32 (output_bfd
, PLT_HEADER_WORD1
, splt
->contents
);
5160 bfd_put_32 (output_bfd
, PLT_HEADER_WORD2
, splt
->contents
+ 4);
5161 bfd_put_32 (output_bfd
, PLT_HEADER_WORD3
, splt
->contents
+ 8);
5162 bfd_put_32 (output_bfd
, PLT_HEADER_WORD4
, splt
->contents
+ 12);
5164 /* The next two words will be filled in by ld.so */
5165 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 16);
5166 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 24);
5168 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
5176 /* We need to use a special link routine to handle the .mdebug section.
5177 We need to merge all instances of these sections together, not write
5178 them all out sequentially. */
5181 elf64_alpha_final_link (abfd
, info
)
5183 struct bfd_link_info
*info
;
5186 struct bfd_link_order
*p
;
5187 asection
*mdebug_sec
;
5188 struct ecoff_debug_info debug
;
5189 const struct ecoff_debug_swap
*swap
5190 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
5191 HDRR
*symhdr
= &debug
.symbolic_header
;
5192 PTR mdebug_handle
= NULL
;
5194 /* Go through the sections and collect the mdebug information. */
5196 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5198 if (strcmp (o
->name
, ".mdebug") == 0)
5200 struct extsym_info einfo
;
5202 /* We have found the .mdebug section in the output file.
5203 Look through all the link_orders comprising it and merge
5204 the information together. */
5205 symhdr
->magic
= swap
->sym_magic
;
5206 /* FIXME: What should the version stamp be? */
5208 symhdr
->ilineMax
= 0;
5212 symhdr
->isymMax
= 0;
5213 symhdr
->ioptMax
= 0;
5214 symhdr
->iauxMax
= 0;
5216 symhdr
->issExtMax
= 0;
5219 symhdr
->iextMax
= 0;
5221 /* We accumulate the debugging information itself in the
5222 debug_info structure. */
5224 debug
.external_dnr
= NULL
;
5225 debug
.external_pdr
= NULL
;
5226 debug
.external_sym
= NULL
;
5227 debug
.external_opt
= NULL
;
5228 debug
.external_aux
= NULL
;
5230 debug
.ssext
= debug
.ssext_end
= NULL
;
5231 debug
.external_fdr
= NULL
;
5232 debug
.external_rfd
= NULL
;
5233 debug
.external_ext
= debug
.external_ext_end
= NULL
;
5235 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
5236 if (mdebug_handle
== (PTR
) NULL
)
5245 static const char * const name
[] =
5247 ".text", ".init", ".fini", ".data",
5248 ".rodata", ".sdata", ".sbss", ".bss"
5250 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
5251 scRData
, scSData
, scSBss
, scBss
};
5254 esym
.cobol_main
= 0;
5258 esym
.asym
.iss
= issNil
;
5259 esym
.asym
.st
= stLocal
;
5260 esym
.asym
.reserved
= 0;
5261 esym
.asym
.index
= indexNil
;
5262 for (i
= 0; i
< 8; i
++)
5264 esym
.asym
.sc
= sc
[i
];
5265 s
= bfd_get_section_by_name (abfd
, name
[i
]);
5268 esym
.asym
.value
= s
->vma
;
5269 last
= s
->vma
+ s
->_raw_size
;
5272 esym
.asym
.value
= last
;
5274 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
5280 for (p
= o
->link_order_head
;
5281 p
!= (struct bfd_link_order
*) NULL
;
5284 asection
*input_section
;
5286 const struct ecoff_debug_swap
*input_swap
;
5287 struct ecoff_debug_info input_debug
;
5291 if (p
->type
!= bfd_indirect_link_order
)
5293 if (p
->type
== bfd_data_link_order
)
5298 input_section
= p
->u
.indirect
.section
;
5299 input_bfd
= input_section
->owner
;
5301 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
5302 || (get_elf_backend_data (input_bfd
)
5303 ->elf_backend_ecoff_debug_swap
) == NULL
)
5305 /* I don't know what a non ALPHA ELF bfd would be
5306 doing with a .mdebug section, but I don't really
5307 want to deal with it. */
5311 input_swap
= (get_elf_backend_data (input_bfd
)
5312 ->elf_backend_ecoff_debug_swap
);
5314 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
5316 /* The ECOFF linking code expects that we have already
5317 read in the debugging information and set up an
5318 ecoff_debug_info structure, so we do that now. */
5319 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
5323 if (! (bfd_ecoff_debug_accumulate
5324 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
5325 &input_debug
, input_swap
, info
)))
5328 /* Loop through the external symbols. For each one with
5329 interesting information, try to find the symbol in
5330 the linker global hash table and save the information
5331 for the output external symbols. */
5332 eraw_src
= input_debug
.external_ext
;
5333 eraw_end
= (eraw_src
5334 + (input_debug
.symbolic_header
.iextMax
5335 * input_swap
->external_ext_size
));
5337 eraw_src
< eraw_end
;
5338 eraw_src
+= input_swap
->external_ext_size
)
5342 struct alpha_elf_link_hash_entry
*h
;
5344 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
5345 if (ext
.asym
.sc
== scNil
5346 || ext
.asym
.sc
== scUndefined
5347 || ext
.asym
.sc
== scSUndefined
)
5350 name
= input_debug
.ssext
+ ext
.asym
.iss
;
5351 h
= alpha_elf_link_hash_lookup (alpha_elf_hash_table (info
),
5352 name
, false, false, true);
5353 if (h
== NULL
|| h
->esym
.ifd
!= -2)
5359 < input_debug
.symbolic_header
.ifdMax
);
5360 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
5366 /* Free up the information we just read. */
5367 free (input_debug
.line
);
5368 free (input_debug
.external_dnr
);
5369 free (input_debug
.external_pdr
);
5370 free (input_debug
.external_sym
);
5371 free (input_debug
.external_opt
);
5372 free (input_debug
.external_aux
);
5373 free (input_debug
.ss
);
5374 free (input_debug
.ssext
);
5375 free (input_debug
.external_fdr
);
5376 free (input_debug
.external_rfd
);
5377 free (input_debug
.external_ext
);
5379 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5380 elf_link_input_bfd ignores this section. */
5381 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
5384 /* Build the external symbol information. */
5387 einfo
.debug
= &debug
;
5389 einfo
.failed
= false;
5390 elf_link_hash_traverse (elf_hash_table (info
),
5391 elf64_alpha_output_extsym
,
5396 /* Set the size of the .mdebug section. */
5397 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
5399 /* Skip this section later on (I don't think this currently
5400 matters, but someday it might). */
5401 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
5407 /* Invoke the regular ELF backend linker to do all the work. */
5408 if (! bfd_elf64_bfd_final_link (abfd
, info
))
5411 /* Now write out the computed sections. */
5413 /* The .got subsections... */
5415 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
5416 for (i
= alpha_elf_hash_table(info
)->got_list
;
5418 i
= alpha_elf_tdata(i
)->got_link_next
)
5422 /* elf_bfd_final_link already did everything in dynobj. */
5426 sgot
= alpha_elf_tdata(i
)->got
;
5427 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
5429 (file_ptr
) sgot
->output_offset
,
5435 if (mdebug_sec
!= (asection
*) NULL
)
5437 BFD_ASSERT (abfd
->output_has_begun
);
5438 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5440 mdebug_sec
->filepos
))
5443 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5449 static enum elf_reloc_type_class
5450 elf64_alpha_reloc_type_class (rela
)
5451 const Elf_Internal_Rela
*rela
;
5453 switch ((int) ELF64_R_TYPE (rela
->r_info
))
5455 case R_ALPHA_RELATIVE
:
5456 return reloc_class_relative
;
5457 case R_ALPHA_JMP_SLOT
:
5458 return reloc_class_plt
;
5460 return reloc_class_copy
;
5462 return reloc_class_normal
;
5466 /* ECOFF swapping routines. These are used when dealing with the
5467 .mdebug section, which is in the ECOFF debugging format. Copied
5468 from elf32-mips.c. */
5469 static const struct ecoff_debug_swap
5470 elf64_alpha_ecoff_debug_swap
=
5472 /* Symbol table magic number. */
5474 /* Alignment of debugging information. E.g., 4. */
5476 /* Sizes of external symbolic information. */
5477 sizeof (struct hdr_ext
),
5478 sizeof (struct dnr_ext
),
5479 sizeof (struct pdr_ext
),
5480 sizeof (struct sym_ext
),
5481 sizeof (struct opt_ext
),
5482 sizeof (struct fdr_ext
),
5483 sizeof (struct rfd_ext
),
5484 sizeof (struct ext_ext
),
5485 /* Functions to swap in external symbolic data. */
5494 _bfd_ecoff_swap_tir_in
,
5495 _bfd_ecoff_swap_rndx_in
,
5496 /* Functions to swap out external symbolic data. */
5505 _bfd_ecoff_swap_tir_out
,
5506 _bfd_ecoff_swap_rndx_out
,
5507 /* Function to read in symbolic data. */
5508 elf64_alpha_read_ecoff_info
5511 /* Use a non-standard hash bucket size of 8. */
5513 const struct elf_size_info alpha_elf_size_info
=
5515 sizeof (Elf64_External_Ehdr
),
5516 sizeof (Elf64_External_Phdr
),
5517 sizeof (Elf64_External_Shdr
),
5518 sizeof (Elf64_External_Rel
),
5519 sizeof (Elf64_External_Rela
),
5520 sizeof (Elf64_External_Sym
),
5521 sizeof (Elf64_External_Dyn
),
5522 sizeof (Elf_External_Note
),
5526 ELFCLASS64
, EV_CURRENT
,
5527 bfd_elf64_write_out_phdrs
,
5528 bfd_elf64_write_shdrs_and_ehdr
,
5529 bfd_elf64_write_relocs
,
5530 bfd_elf64_swap_symbol_in
,
5531 bfd_elf64_swap_symbol_out
,
5532 bfd_elf64_slurp_reloc_table
,
5533 bfd_elf64_slurp_symbol_table
,
5534 bfd_elf64_swap_dyn_in
,
5535 bfd_elf64_swap_dyn_out
,
5542 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5543 #define TARGET_LITTLE_NAME "elf64-alpha"
5544 #define ELF_ARCH bfd_arch_alpha
5545 #define ELF_MACHINE_CODE EM_ALPHA
5546 #define ELF_MAXPAGESIZE 0x10000
5548 #define bfd_elf64_bfd_link_hash_table_create \
5549 elf64_alpha_bfd_link_hash_table_create
5551 #define bfd_elf64_bfd_reloc_type_lookup \
5552 elf64_alpha_bfd_reloc_type_lookup
5553 #define elf_info_to_howto \
5554 elf64_alpha_info_to_howto
5556 #define bfd_elf64_mkobject \
5557 elf64_alpha_mkobject
5558 #define elf_backend_object_p \
5559 elf64_alpha_object_p
5561 #define elf_backend_section_from_shdr \
5562 elf64_alpha_section_from_shdr
5563 #define elf_backend_section_flags \
5564 elf64_alpha_section_flags
5565 #define elf_backend_fake_sections \
5566 elf64_alpha_fake_sections
5568 #define bfd_elf64_bfd_is_local_label_name \
5569 elf64_alpha_is_local_label_name
5570 #define bfd_elf64_find_nearest_line \
5571 elf64_alpha_find_nearest_line
5572 #define bfd_elf64_bfd_relax_section \
5573 elf64_alpha_relax_section
5575 #define elf_backend_add_symbol_hook \
5576 elf64_alpha_add_symbol_hook
5577 #define elf_backend_check_relocs \
5578 elf64_alpha_check_relocs
5579 #define elf_backend_create_dynamic_sections \
5580 elf64_alpha_create_dynamic_sections
5581 #define elf_backend_adjust_dynamic_symbol \
5582 elf64_alpha_adjust_dynamic_symbol
5583 #define elf_backend_always_size_sections \
5584 elf64_alpha_always_size_sections
5585 #define elf_backend_size_dynamic_sections \
5586 elf64_alpha_size_dynamic_sections
5587 #define elf_backend_relocate_section \
5588 elf64_alpha_relocate_section
5589 #define elf_backend_finish_dynamic_symbol \
5590 elf64_alpha_finish_dynamic_symbol
5591 #define elf_backend_finish_dynamic_sections \
5592 elf64_alpha_finish_dynamic_sections
5593 #define bfd_elf64_bfd_final_link \
5594 elf64_alpha_final_link
5595 #define elf_backend_reloc_type_class \
5596 elf64_alpha_reloc_type_class
5598 #define elf_backend_ecoff_debug_swap \
5599 &elf64_alpha_ecoff_debug_swap
5601 #define elf_backend_size_info \
5604 /* A few constants that determine how the .plt section is set up. */
5605 #define elf_backend_want_got_plt 0
5606 #define elf_backend_plt_readonly 0
5607 #define elf_backend_want_plt_sym 1
5608 #define elf_backend_got_header_size 0
5609 #define elf_backend_plt_header_size PLT_HEADER_SIZE
5611 #include "elf64-target.h"