1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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 bfd_boolean 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
*, Elf_Internal_Rela
*));
71 static bfd_boolean elf64_alpha_mkobject
73 static bfd_boolean elf64_alpha_object_p
75 static bfd_boolean elf64_alpha_section_flags
76 PARAMS ((flagword
*, const Elf_Internal_Shdr
*));
77 static bfd_boolean elf64_alpha_fake_sections
78 PARAMS ((bfd
*, Elf_Internal_Shdr
*, asection
*));
79 static bfd_boolean elf64_alpha_create_got_section
80 PARAMS ((bfd
*, struct bfd_link_info
*));
81 static bfd_boolean elf64_alpha_create_dynamic_sections
82 PARAMS ((bfd
*, struct bfd_link_info
*));
84 static bfd_boolean elf64_alpha_read_ecoff_info
85 PARAMS ((bfd
*, asection
*, struct ecoff_debug_info
*));
86 static bfd_boolean elf64_alpha_is_local_label_name
87 PARAMS ((bfd
*, const char *));
88 static bfd_boolean elf64_alpha_find_nearest_line
89 PARAMS ((bfd
*, asection
*, asymbol
**, bfd_vma
, const char **,
90 const char **, unsigned int *));
92 #if defined(__STDC__) || defined(ALMOST_STDC)
93 struct alpha_elf_link_hash_entry
;
96 static bfd_boolean elf64_alpha_output_extsym
97 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
99 static bfd_boolean elf64_alpha_can_merge_gots
100 PARAMS ((bfd
*, bfd
*));
101 static void elf64_alpha_merge_gots
102 PARAMS ((bfd
*, bfd
*));
103 static bfd_boolean elf64_alpha_calc_got_offsets_for_symbol
104 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
105 static void elf64_alpha_calc_got_offsets
106 PARAMS ((struct bfd_link_info
*));
107 static bfd_boolean elf64_alpha_size_got_sections
108 PARAMS ((struct bfd_link_info
*));
109 static bfd_boolean elf64_alpha_size_plt_section
110 PARAMS ((struct bfd_link_info
*));
111 static bfd_boolean elf64_alpha_size_plt_section_1
112 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
113 static bfd_boolean elf64_alpha_always_size_sections
114 PARAMS ((bfd
*, struct bfd_link_info
*));
115 static int alpha_dynamic_entries_for_reloc
116 PARAMS ((int, int, int));
117 static bfd_boolean elf64_alpha_calc_dynrel_sizes
118 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
119 static bfd_boolean elf64_alpha_size_rela_got_section
120 PARAMS ((struct bfd_link_info
*));
121 static bfd_boolean elf64_alpha_size_rela_got_1
122 PARAMS ((struct alpha_elf_link_hash_entry
*, struct bfd_link_info
*));
123 static bfd_boolean elf64_alpha_add_symbol_hook
124 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Sym
*,
125 const char **, flagword
*, asection
**, bfd_vma
*));
126 static struct alpha_elf_got_entry
*get_got_entry
127 PARAMS ((bfd
*, struct alpha_elf_link_hash_entry
*, unsigned long,
128 unsigned long, bfd_vma
));
129 static bfd_boolean elf64_alpha_check_relocs
130 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*sec
,
131 const Elf_Internal_Rela
*));
132 static bfd_boolean elf64_alpha_adjust_dynamic_symbol
133 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
134 static bfd_boolean elf64_alpha_size_dynamic_sections
135 PARAMS ((bfd
*, struct bfd_link_info
*));
136 static void elf64_alpha_emit_dynrel
137 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*, asection
*,
138 bfd_vma
, long, long, bfd_vma
));
139 static bfd_boolean elf64_alpha_relocate_section_r
140 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
141 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
142 static bfd_boolean elf64_alpha_relocate_section
143 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
144 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
145 static bfd_boolean elf64_alpha_finish_dynamic_symbol
146 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
147 Elf_Internal_Sym
*));
148 static bfd_boolean elf64_alpha_finish_dynamic_sections
149 PARAMS ((bfd
*, struct bfd_link_info
*));
150 static bfd_boolean elf64_alpha_final_link
151 PARAMS ((bfd
*, struct bfd_link_info
*));
152 static bfd_boolean elf64_alpha_merge_ind_symbols
153 PARAMS ((struct alpha_elf_link_hash_entry
*, PTR
));
154 static Elf_Internal_Rela
* elf64_alpha_find_reloc_at_ofs
155 PARAMS ((Elf_Internal_Rela
*, Elf_Internal_Rela
*, bfd_vma
, int));
156 static enum elf_reloc_type_class elf64_alpha_reloc_type_class
157 PARAMS ((const Elf_Internal_Rela
*));
159 struct alpha_elf_link_hash_entry
161 struct elf_link_hash_entry root
;
163 /* External symbol information. */
166 /* Cumulative flags for all the .got entries. */
169 /* Contexts in which a literal was referenced. */
170 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
171 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
172 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
173 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
174 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
175 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
176 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x38
177 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x40
178 #define ALPHA_ELF_LINK_HASH_PLT_LOC 0x80
180 /* Used to undo the localization of a plt symbol. */
181 asection
*plt_old_section
;
182 bfd_vma plt_old_value
;
184 /* Used to implement multiple .got subsections. */
185 struct alpha_elf_got_entry
187 struct alpha_elf_got_entry
*next
;
189 /* Which .got subsection? */
192 /* The addend in effect for this entry. */
195 /* The .got offset for this entry. */
198 /* How many references to this entry? */
201 /* The relocation type of this entry. */
202 unsigned char reloc_type
;
204 /* How a LITERAL is used. */
207 /* Have we initialized the dynamic relocation for this entry? */
208 unsigned char reloc_done
;
210 /* Have we adjusted this entry for SEC_MERGE? */
211 unsigned char reloc_xlated
;
214 /* Used to count non-got, non-plt relocations for delayed sizing
215 of relocation sections. */
216 struct alpha_elf_reloc_entry
218 struct alpha_elf_reloc_entry
*next
;
220 /* Which .reloc section? */
223 /* What kind of relocation? */
226 /* Is this against read-only section? */
227 unsigned int reltext
: 1;
229 /* How many did we find? */
234 /* Alpha ELF linker hash table. */
236 struct alpha_elf_link_hash_table
238 struct elf_link_hash_table root
;
240 /* The head of a list of .got subsections linked through
241 alpha_elf_tdata(abfd)->got_link_next. */
245 /* Look up an entry in a Alpha ELF linker hash table. */
247 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
248 ((struct alpha_elf_link_hash_entry *) \
249 elf_link_hash_lookup (&(table)->root, (string), (create), \
252 /* Traverse a Alpha ELF linker hash table. */
254 #define alpha_elf_link_hash_traverse(table, func, info) \
255 (elf_link_hash_traverse \
257 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
260 /* Get the Alpha ELF linker hash table from a link_info structure. */
262 #define alpha_elf_hash_table(p) \
263 ((struct alpha_elf_link_hash_table *) ((p)->hash))
265 /* Get the object's symbols as our own entry type. */
267 #define alpha_elf_sym_hashes(abfd) \
268 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
270 /* Should we do dynamic things to this symbol? This differs from the
271 generic version in that we never need to consider function pointer
272 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
273 address is ever taken. */
275 static inline bfd_boolean
276 alpha_elf_dynamic_symbol_p (h
, info
)
277 struct elf_link_hash_entry
*h
;
278 struct bfd_link_info
*info
;
280 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
283 /* Create an entry in a Alpha ELF linker hash table. */
285 static struct bfd_hash_entry
*
286 elf64_alpha_link_hash_newfunc (entry
, table
, string
)
287 struct bfd_hash_entry
*entry
;
288 struct bfd_hash_table
*table
;
291 struct alpha_elf_link_hash_entry
*ret
=
292 (struct alpha_elf_link_hash_entry
*) entry
;
294 /* Allocate the structure if it has not already been allocated by a
296 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
297 ret
= ((struct alpha_elf_link_hash_entry
*)
298 bfd_hash_allocate (table
,
299 sizeof (struct alpha_elf_link_hash_entry
)));
300 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
301 return (struct bfd_hash_entry
*) ret
;
303 /* Call the allocation method of the superclass. */
304 ret
= ((struct alpha_elf_link_hash_entry
*)
305 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
307 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
309 /* Set local fields. */
310 memset (&ret
->esym
, 0, sizeof (EXTR
));
311 /* We use -2 as a marker to indicate that the information has
312 not been set. -1 means there is no associated ifd. */
315 ret
->got_entries
= NULL
;
316 ret
->reloc_entries
= NULL
;
319 return (struct bfd_hash_entry
*) ret
;
322 /* Create a Alpha ELF linker hash table. */
324 static struct bfd_link_hash_table
*
325 elf64_alpha_bfd_link_hash_table_create (abfd
)
328 struct alpha_elf_link_hash_table
*ret
;
329 bfd_size_type amt
= sizeof (struct alpha_elf_link_hash_table
);
331 ret
= (struct alpha_elf_link_hash_table
*) bfd_zmalloc (amt
);
332 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
335 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
336 elf64_alpha_link_hash_newfunc
))
342 return &ret
->root
.root
;
345 /* We have some private fields hanging off of the elf_tdata structure. */
347 struct alpha_elf_obj_tdata
349 struct elf_obj_tdata root
;
351 /* For every input file, these are the got entries for that object's
353 struct alpha_elf_got_entry
** local_got_entries
;
355 /* For every input file, this is the object that owns the got that
356 this input file uses. */
359 /* For every got, this is a linked list through the objects using this got */
360 bfd
*in_got_link_next
;
362 /* For every got, this is a link to the next got subsegment. */
365 /* For every got, this is the section. */
368 /* For every got, this is it's total number of words. */
371 /* For every got, this is the sum of the number of words required
372 to hold all of the member object's local got. */
376 #define alpha_elf_tdata(abfd) \
377 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
380 elf64_alpha_mkobject (abfd
)
383 bfd_size_type amt
= sizeof (struct alpha_elf_obj_tdata
);
384 abfd
->tdata
.any
= bfd_zalloc (abfd
, amt
);
385 if (abfd
->tdata
.any
== NULL
)
391 elf64_alpha_object_p (abfd
)
394 /* Set the right machine number for an Alpha ELF file. */
395 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
398 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
399 from smaller values. Start with zero, widen, *then* decrement. */
400 #define MINUS_ONE (((bfd_vma)0) - 1)
402 #define SKIP_HOWTO(N) \
403 HOWTO(N, 0, 0, 0, 0, 0, 0, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
405 static reloc_howto_type elf64_alpha_howto_table
[] =
407 HOWTO (R_ALPHA_NONE
, /* type */
409 0, /* size (0 = byte, 1 = short, 2 = long) */
411 TRUE
, /* pc_relative */
413 complain_overflow_dont
, /* complain_on_overflow */
414 elf64_alpha_reloc_nil
, /* special_function */
416 FALSE
, /* partial_inplace */
419 TRUE
), /* pcrel_offset */
421 /* A 32 bit reference to a symbol. */
422 HOWTO (R_ALPHA_REFLONG
, /* type */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
426 FALSE
, /* pc_relative */
428 complain_overflow_bitfield
, /* complain_on_overflow */
429 0, /* special_function */
430 "REFLONG", /* name */
431 FALSE
, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 FALSE
), /* pcrel_offset */
436 /* A 64 bit reference to a symbol. */
437 HOWTO (R_ALPHA_REFQUAD
, /* type */
439 4, /* size (0 = byte, 1 = short, 2 = long) */
441 FALSE
, /* pc_relative */
443 complain_overflow_bitfield
, /* complain_on_overflow */
444 0, /* special_function */
445 "REFQUAD", /* name */
446 FALSE
, /* partial_inplace */
447 MINUS_ONE
, /* src_mask */
448 MINUS_ONE
, /* dst_mask */
449 FALSE
), /* pcrel_offset */
451 /* A 32 bit GP relative offset. This is just like REFLONG except
452 that when the value is used the value of the gp register will be
454 HOWTO (R_ALPHA_GPREL32
, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 FALSE
, /* pc_relative */
460 complain_overflow_bitfield
, /* complain_on_overflow */
461 0, /* special_function */
462 "GPREL32", /* name */
463 FALSE
, /* partial_inplace */
464 0xffffffff, /* src_mask */
465 0xffffffff, /* dst_mask */
466 FALSE
), /* pcrel_offset */
468 /* Used for an instruction that refers to memory off the GP register. */
469 HOWTO (R_ALPHA_LITERAL
, /* type */
471 1, /* size (0 = byte, 1 = short, 2 = long) */
473 FALSE
, /* pc_relative */
475 complain_overflow_signed
, /* complain_on_overflow */
476 0, /* special_function */
477 "ELF_LITERAL", /* name */
478 FALSE
, /* partial_inplace */
479 0xffff, /* src_mask */
480 0xffff, /* dst_mask */
481 FALSE
), /* pcrel_offset */
483 /* This reloc only appears immediately following an ELF_LITERAL reloc.
484 It identifies a use of the literal. The symbol index is special:
485 1 means the literal address is in the base register of a memory
486 format instruction; 2 means the literal address is in the byte
487 offset register of a byte-manipulation instruction; 3 means the
488 literal address is in the target register of a jsr instruction.
489 This does not actually do any relocation. */
490 HOWTO (R_ALPHA_LITUSE
, /* type */
492 1, /* size (0 = byte, 1 = short, 2 = long) */
494 FALSE
, /* pc_relative */
496 complain_overflow_dont
, /* complain_on_overflow */
497 elf64_alpha_reloc_nil
, /* special_function */
499 FALSE
, /* partial_inplace */
502 FALSE
), /* pcrel_offset */
504 /* Load the gp register. This is always used for a ldah instruction
505 which loads the upper 16 bits of the gp register. The symbol
506 index of the GPDISP instruction is an offset in bytes to the lda
507 instruction that loads the lower 16 bits. The value to use for
508 the relocation is the difference between the GP value and the
509 current location; the load will always be done against a register
510 holding the current address.
512 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
513 any offset is present in the instructions, it is an offset from
514 the register to the ldah instruction. This lets us avoid any
515 stupid hackery like inventing a gp value to do partial relocation
516 against. Also unlike ECOFF, we do the whole relocation off of
517 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
518 space consuming bit, that, since all the information was present
519 in the GPDISP_HI16 reloc. */
520 HOWTO (R_ALPHA_GPDISP
, /* type */
522 2, /* size (0 = byte, 1 = short, 2 = long) */
524 FALSE
, /* pc_relative */
526 complain_overflow_dont
, /* complain_on_overflow */
527 elf64_alpha_reloc_gpdisp
, /* special_function */
529 FALSE
, /* partial_inplace */
530 0xffff, /* src_mask */
531 0xffff, /* dst_mask */
532 TRUE
), /* pcrel_offset */
534 /* A 21 bit branch. */
535 HOWTO (R_ALPHA_BRADDR
, /* type */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
539 TRUE
, /* pc_relative */
541 complain_overflow_signed
, /* complain_on_overflow */
542 0, /* special_function */
544 FALSE
, /* partial_inplace */
545 0x1fffff, /* src_mask */
546 0x1fffff, /* dst_mask */
547 TRUE
), /* pcrel_offset */
549 /* A hint for a jump to a register. */
550 HOWTO (R_ALPHA_HINT
, /* type */
552 1, /* size (0 = byte, 1 = short, 2 = long) */
554 TRUE
, /* pc_relative */
556 complain_overflow_dont
, /* complain_on_overflow */
557 0, /* special_function */
559 FALSE
, /* partial_inplace */
560 0x3fff, /* src_mask */
561 0x3fff, /* dst_mask */
562 TRUE
), /* pcrel_offset */
564 /* 16 bit PC relative offset. */
565 HOWTO (R_ALPHA_SREL16
, /* type */
567 1, /* size (0 = byte, 1 = short, 2 = long) */
569 TRUE
, /* pc_relative */
571 complain_overflow_signed
, /* complain_on_overflow */
572 0, /* special_function */
574 FALSE
, /* partial_inplace */
575 0xffff, /* src_mask */
576 0xffff, /* dst_mask */
577 TRUE
), /* pcrel_offset */
579 /* 32 bit PC relative offset. */
580 HOWTO (R_ALPHA_SREL32
, /* type */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
584 TRUE
, /* pc_relative */
586 complain_overflow_signed
, /* complain_on_overflow */
587 0, /* special_function */
589 FALSE
, /* partial_inplace */
590 0xffffffff, /* src_mask */
591 0xffffffff, /* dst_mask */
592 TRUE
), /* pcrel_offset */
594 /* A 64 bit PC relative offset. */
595 HOWTO (R_ALPHA_SREL64
, /* type */
597 4, /* size (0 = byte, 1 = short, 2 = long) */
599 TRUE
, /* pc_relative */
601 complain_overflow_signed
, /* complain_on_overflow */
602 0, /* special_function */
604 FALSE
, /* partial_inplace */
605 MINUS_ONE
, /* src_mask */
606 MINUS_ONE
, /* dst_mask */
607 TRUE
), /* pcrel_offset */
609 /* Skip 12 - 16; deprecated ECOFF relocs. */
616 /* The high 16 bits of the displacement from GP to the target. */
617 HOWTO (R_ALPHA_GPRELHIGH
,
619 1, /* size (0 = byte, 1 = short, 2 = long) */
621 FALSE
, /* pc_relative */
623 complain_overflow_signed
, /* complain_on_overflow */
624 0, /* special_function */
625 "GPRELHIGH", /* name */
626 FALSE
, /* partial_inplace */
627 0xffff, /* src_mask */
628 0xffff, /* dst_mask */
629 FALSE
), /* pcrel_offset */
631 /* The low 16 bits of the displacement from GP to the target. */
632 HOWTO (R_ALPHA_GPRELLOW
,
634 1, /* size (0 = byte, 1 = short, 2 = long) */
636 FALSE
, /* pc_relative */
638 complain_overflow_dont
, /* complain_on_overflow */
639 0, /* special_function */
640 "GPRELLOW", /* name */
641 FALSE
, /* partial_inplace */
642 0xffff, /* src_mask */
643 0xffff, /* dst_mask */
644 FALSE
), /* pcrel_offset */
646 /* A 16-bit displacement from the GP to the target. */
647 HOWTO (R_ALPHA_GPREL16
,
649 1, /* size (0 = byte, 1 = short, 2 = long) */
651 FALSE
, /* pc_relative */
653 complain_overflow_signed
, /* complain_on_overflow */
654 0, /* special_function */
655 "GPREL16", /* name */
656 FALSE
, /* partial_inplace */
657 0xffff, /* src_mask */
658 0xffff, /* dst_mask */
659 FALSE
), /* pcrel_offset */
661 /* Skip 20 - 23; deprecated ECOFF relocs. */
667 /* Misc ELF relocations. */
669 /* A dynamic relocation to copy the target into our .dynbss section. */
670 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
671 is present because every other ELF has one, but should not be used
672 because .dynbss is an ugly thing. */
679 complain_overflow_dont
,
680 bfd_elf_generic_reloc
,
687 /* A dynamic relocation for a .got entry. */
688 HOWTO (R_ALPHA_GLOB_DAT
,
694 complain_overflow_dont
,
695 bfd_elf_generic_reloc
,
702 /* A dynamic relocation for a .plt entry. */
703 HOWTO (R_ALPHA_JMP_SLOT
,
709 complain_overflow_dont
,
710 bfd_elf_generic_reloc
,
717 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
718 HOWTO (R_ALPHA_RELATIVE
,
724 complain_overflow_dont
,
725 bfd_elf_generic_reloc
,
732 /* A 21 bit branch that adjusts for gp loads. */
733 HOWTO (R_ALPHA_BRSGP
, /* type */
735 2, /* size (0 = byte, 1 = short, 2 = long) */
737 TRUE
, /* pc_relative */
739 complain_overflow_signed
, /* complain_on_overflow */
740 0, /* special_function */
742 FALSE
, /* partial_inplace */
743 0x1fffff, /* src_mask */
744 0x1fffff, /* dst_mask */
745 TRUE
), /* pcrel_offset */
747 /* Creates a tls_index for the symbol in the got. */
748 HOWTO (R_ALPHA_TLSGD
, /* type */
750 1, /* size (0 = byte, 1 = short, 2 = long) */
752 FALSE
, /* pc_relative */
754 complain_overflow_signed
, /* complain_on_overflow */
755 0, /* special_function */
757 FALSE
, /* partial_inplace */
758 0xffff, /* src_mask */
759 0xffff, /* dst_mask */
760 FALSE
), /* pcrel_offset */
762 /* Creates a tls_index for the (current) module in the got. */
763 HOWTO (R_ALPHA_TLSLDM
, /* type */
765 1, /* size (0 = byte, 1 = short, 2 = long) */
767 FALSE
, /* pc_relative */
769 complain_overflow_signed
, /* complain_on_overflow */
770 0, /* special_function */
772 FALSE
, /* partial_inplace */
773 0xffff, /* src_mask */
774 0xffff, /* dst_mask */
775 FALSE
), /* pcrel_offset */
777 /* A dynamic relocation for a DTP module entry. */
778 HOWTO (R_ALPHA_DTPMOD64
, /* type */
780 4, /* size (0 = byte, 1 = short, 2 = long) */
782 FALSE
, /* pc_relative */
784 complain_overflow_bitfield
, /* complain_on_overflow */
785 0, /* special_function */
786 "DTPMOD64", /* name */
787 FALSE
, /* partial_inplace */
788 MINUS_ONE
, /* src_mask */
789 MINUS_ONE
, /* dst_mask */
790 FALSE
), /* pcrel_offset */
792 /* Creates a 64-bit offset in the got for the displacement
793 from DTP to the target. */
794 HOWTO (R_ALPHA_GOTDTPREL
, /* type */
796 1, /* size (0 = byte, 1 = short, 2 = long) */
798 FALSE
, /* pc_relative */
800 complain_overflow_signed
, /* complain_on_overflow */
801 0, /* special_function */
802 "GOTDTPREL", /* name */
803 FALSE
, /* partial_inplace */
804 0xffff, /* src_mask */
805 0xffff, /* dst_mask */
806 FALSE
), /* pcrel_offset */
808 /* A dynamic relocation for a displacement from DTP to the target. */
809 HOWTO (R_ALPHA_DTPREL64
, /* type */
811 4, /* size (0 = byte, 1 = short, 2 = long) */
813 FALSE
, /* pc_relative */
815 complain_overflow_bitfield
, /* complain_on_overflow */
816 0, /* special_function */
817 "DTPREL64", /* name */
818 FALSE
, /* partial_inplace */
819 MINUS_ONE
, /* src_mask */
820 MINUS_ONE
, /* dst_mask */
821 FALSE
), /* pcrel_offset */
823 /* The high 16 bits of the displacement from DTP to the target. */
824 HOWTO (R_ALPHA_DTPRELHI
, /* type */
826 1, /* size (0 = byte, 1 = short, 2 = long) */
828 FALSE
, /* pc_relative */
830 complain_overflow_signed
, /* complain_on_overflow */
831 0, /* special_function */
832 "DTPRELHI", /* name */
833 FALSE
, /* partial_inplace */
834 0xffff, /* src_mask */
835 0xffff, /* dst_mask */
836 FALSE
), /* pcrel_offset */
838 /* The low 16 bits of the displacement from DTP to the target. */
839 HOWTO (R_ALPHA_DTPRELLO
, /* type */
841 1, /* size (0 = byte, 1 = short, 2 = long) */
843 FALSE
, /* pc_relative */
845 complain_overflow_dont
, /* complain_on_overflow */
846 0, /* special_function */
847 "DTPRELLO", /* name */
848 FALSE
, /* partial_inplace */
849 0xffff, /* src_mask */
850 0xffff, /* dst_mask */
851 FALSE
), /* pcrel_offset */
853 /* A 16-bit displacement from DTP to the target. */
854 HOWTO (R_ALPHA_DTPREL16
, /* type */
856 1, /* size (0 = byte, 1 = short, 2 = long) */
858 FALSE
, /* pc_relative */
860 complain_overflow_signed
, /* complain_on_overflow */
861 0, /* special_function */
862 "DTPREL16", /* name */
863 FALSE
, /* partial_inplace */
864 0xffff, /* src_mask */
865 0xffff, /* dst_mask */
866 FALSE
), /* pcrel_offset */
868 /* Creates a 64-bit offset in the got for the displacement
869 from TP to the target. */
870 HOWTO (R_ALPHA_GOTTPREL
, /* type */
872 1, /* size (0 = byte, 1 = short, 2 = long) */
874 FALSE
, /* pc_relative */
876 complain_overflow_signed
, /* complain_on_overflow */
877 0, /* special_function */
878 "GOTTPREL", /* name */
879 FALSE
, /* partial_inplace */
880 0xffff, /* src_mask */
881 0xffff, /* dst_mask */
882 FALSE
), /* pcrel_offset */
884 /* A dynamic relocation for a displacement from TP to the target. */
885 HOWTO (R_ALPHA_TPREL64
, /* type */
887 4, /* size (0 = byte, 1 = short, 2 = long) */
889 FALSE
, /* pc_relative */
891 complain_overflow_bitfield
, /* complain_on_overflow */
892 0, /* special_function */
893 "TPREL64", /* name */
894 FALSE
, /* partial_inplace */
895 MINUS_ONE
, /* src_mask */
896 MINUS_ONE
, /* dst_mask */
897 FALSE
), /* pcrel_offset */
899 /* The high 16 bits of the displacement from TP to the target. */
900 HOWTO (R_ALPHA_TPRELHI
, /* type */
902 1, /* size (0 = byte, 1 = short, 2 = long) */
904 FALSE
, /* pc_relative */
906 complain_overflow_signed
, /* complain_on_overflow */
907 0, /* special_function */
908 "TPRELHI", /* name */
909 FALSE
, /* partial_inplace */
910 0xffff, /* src_mask */
911 0xffff, /* dst_mask */
912 FALSE
), /* pcrel_offset */
914 /* The low 16 bits of the displacement from TP to the target. */
915 HOWTO (R_ALPHA_TPRELLO
, /* type */
917 1, /* size (0 = byte, 1 = short, 2 = long) */
919 FALSE
, /* pc_relative */
921 complain_overflow_dont
, /* complain_on_overflow */
922 0, /* special_function */
923 "TPRELLO", /* name */
924 FALSE
, /* partial_inplace */
925 0xffff, /* src_mask */
926 0xffff, /* dst_mask */
927 FALSE
), /* pcrel_offset */
929 /* A 16-bit displacement from TP to the target. */
930 HOWTO (R_ALPHA_TPREL16
, /* type */
932 1, /* size (0 = byte, 1 = short, 2 = long) */
934 FALSE
, /* pc_relative */
936 complain_overflow_signed
, /* complain_on_overflow */
937 0, /* special_function */
938 "TPREL16", /* name */
939 FALSE
, /* partial_inplace */
940 0xffff, /* src_mask */
941 0xffff, /* dst_mask */
942 FALSE
), /* pcrel_offset */
945 /* A relocation function which doesn't do anything. */
947 static bfd_reloc_status_type
948 elf64_alpha_reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
949 bfd
*abfd ATTRIBUTE_UNUSED
;
951 asymbol
*sym ATTRIBUTE_UNUSED
;
952 PTR data ATTRIBUTE_UNUSED
;
955 char **error_message ATTRIBUTE_UNUSED
;
958 reloc
->address
+= sec
->output_offset
;
962 /* A relocation function used for an unsupported reloc. */
964 static bfd_reloc_status_type
965 elf64_alpha_reloc_bad (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
966 bfd
*abfd ATTRIBUTE_UNUSED
;
968 asymbol
*sym ATTRIBUTE_UNUSED
;
969 PTR data ATTRIBUTE_UNUSED
;
972 char **error_message ATTRIBUTE_UNUSED
;
975 reloc
->address
+= sec
->output_offset
;
976 return bfd_reloc_notsupported
;
979 /* Do the work of the GPDISP relocation. */
981 static bfd_reloc_status_type
982 elf64_alpha_do_reloc_gpdisp (abfd
, gpdisp
, p_ldah
, p_lda
)
988 bfd_reloc_status_type ret
= bfd_reloc_ok
;
990 unsigned long i_ldah
, i_lda
;
992 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
993 i_lda
= bfd_get_32 (abfd
, p_lda
);
995 /* Complain if the instructions are not correct. */
996 if (((i_ldah
>> 26) & 0x3f) != 0x09
997 || ((i_lda
>> 26) & 0x3f) != 0x08)
998 ret
= bfd_reloc_dangerous
;
1000 /* Extract the user-supplied offset, mirroring the sign extensions
1001 that the instructions perform. */
1002 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
1003 addend
= (addend
^ 0x80008000) - 0x80008000;
1007 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
1008 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
1009 ret
= bfd_reloc_overflow
;
1011 /* compensate for the sign extension again. */
1012 i_ldah
= ((i_ldah
& 0xffff0000)
1013 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
1014 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
1016 bfd_put_32 (abfd
, (bfd_vma
) i_ldah
, p_ldah
);
1017 bfd_put_32 (abfd
, (bfd_vma
) i_lda
, p_lda
);
1022 /* The special function for the GPDISP reloc. */
1024 static bfd_reloc_status_type
1025 elf64_alpha_reloc_gpdisp (abfd
, reloc_entry
, sym
, data
, input_section
,
1026 output_bfd
, err_msg
)
1028 arelent
*reloc_entry
;
1029 asymbol
*sym ATTRIBUTE_UNUSED
;
1031 asection
*input_section
;
1035 bfd_reloc_status_type ret
;
1036 bfd_vma gp
, relocation
;
1037 bfd_vma high_address
;
1038 bfd_byte
*p_ldah
, *p_lda
;
1040 /* Don't do anything if we're not doing a final link. */
1043 reloc_entry
->address
+= input_section
->output_offset
;
1044 return bfd_reloc_ok
;
1047 high_address
= bfd_get_section_limit (abfd
, input_section
);
1048 if (reloc_entry
->address
> high_address
1049 || reloc_entry
->address
+ reloc_entry
->addend
> high_address
)
1050 return bfd_reloc_outofrange
;
1052 /* The gp used in the portion of the output object to which this
1053 input object belongs is cached on the input bfd. */
1054 gp
= _bfd_get_gp_value (abfd
);
1056 relocation
= (input_section
->output_section
->vma
1057 + input_section
->output_offset
1058 + reloc_entry
->address
);
1060 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
1061 p_lda
= p_ldah
+ reloc_entry
->addend
;
1063 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
1065 /* Complain if the instructions are not correct. */
1066 if (ret
== bfd_reloc_dangerous
)
1067 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
1072 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1074 struct elf_reloc_map
1076 bfd_reloc_code_real_type bfd_reloc_val
;
1080 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
1082 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
1083 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
1084 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
1085 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
1086 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
1087 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
1088 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
1089 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
1090 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
1091 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
1092 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
1093 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
1094 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
1095 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
1096 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
1097 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
1098 {BFD_RELOC_ALPHA_BRSGP
, R_ALPHA_BRSGP
},
1099 {BFD_RELOC_ALPHA_TLSGD
, R_ALPHA_TLSGD
},
1100 {BFD_RELOC_ALPHA_TLSLDM
, R_ALPHA_TLSLDM
},
1101 {BFD_RELOC_ALPHA_DTPMOD64
, R_ALPHA_DTPMOD64
},
1102 {BFD_RELOC_ALPHA_GOTDTPREL16
, R_ALPHA_GOTDTPREL
},
1103 {BFD_RELOC_ALPHA_DTPREL64
, R_ALPHA_DTPREL64
},
1104 {BFD_RELOC_ALPHA_DTPREL_HI16
, R_ALPHA_DTPRELHI
},
1105 {BFD_RELOC_ALPHA_DTPREL_LO16
, R_ALPHA_DTPRELLO
},
1106 {BFD_RELOC_ALPHA_DTPREL16
, R_ALPHA_DTPREL16
},
1107 {BFD_RELOC_ALPHA_GOTTPREL16
, R_ALPHA_GOTTPREL
},
1108 {BFD_RELOC_ALPHA_TPREL64
, R_ALPHA_TPREL64
},
1109 {BFD_RELOC_ALPHA_TPREL_HI16
, R_ALPHA_TPRELHI
},
1110 {BFD_RELOC_ALPHA_TPREL_LO16
, R_ALPHA_TPRELLO
},
1111 {BFD_RELOC_ALPHA_TPREL16
, R_ALPHA_TPREL16
},
1114 /* Given a BFD reloc type, return a HOWTO structure. */
1116 static reloc_howto_type
*
1117 elf64_alpha_bfd_reloc_type_lookup (abfd
, code
)
1118 bfd
*abfd ATTRIBUTE_UNUSED
;
1119 bfd_reloc_code_real_type code
;
1121 const struct elf_reloc_map
*i
, *e
;
1122 i
= e
= elf64_alpha_reloc_map
;
1123 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1126 if (i
->bfd_reloc_val
== code
)
1127 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1132 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1135 elf64_alpha_info_to_howto (abfd
, cache_ptr
, dst
)
1136 bfd
*abfd ATTRIBUTE_UNUSED
;
1138 Elf_Internal_Rela
*dst
;
1142 r_type
= ELF64_R_TYPE(dst
->r_info
);
1143 BFD_ASSERT (r_type
< (unsigned int) R_ALPHA_max
);
1144 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1147 /* These two relocations create a two-word entry in the got. */
1148 #define alpha_got_entry_size(r_type) \
1149 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1151 /* This is PT_TLS segment p_vaddr. */
1152 #define alpha_get_dtprel_base(info) \
1153 (elf_hash_table (info)->tls_sec->vma)
1155 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1156 is assigned offset round(16, PT_TLS p_align). */
1157 #define alpha_get_tprel_base(info) \
1158 (elf_hash_table (info)->tls_sec->vma \
1159 - align_power ((bfd_vma) 16, \
1160 elf_hash_table (info)->tls_sec->alignment_power))
1162 /* These functions do relaxation for Alpha ELF.
1164 Currently I'm only handling what I can do with existing compiler
1165 and assembler support, which means no instructions are removed,
1166 though some may be nopped. At this time GCC does not emit enough
1167 information to do all of the relaxing that is possible. It will
1168 take some not small amount of work for that to happen.
1170 There are a couple of interesting papers that I once read on this
1171 subject, that I cannot find references to at the moment, that
1172 related to Alpha in particular. They are by David Wall, then of
1176 #define OP_LDAH 0x09
1177 #define INSN_JSR 0x68004000
1178 #define INSN_JSR_MASK 0xfc00c000
1182 #define INSN_UNOP 0x2ffe0000
1183 #define INSN_ADDQ 0x40000400
1184 #define INSN_RDUNIQ 0x0000009e
1186 struct alpha_relax_info
1191 Elf_Internal_Shdr
*symtab_hdr
;
1192 Elf_Internal_Rela
*relocs
, *relend
;
1193 struct bfd_link_info
*link_info
;
1197 struct alpha_elf_link_hash_entry
*h
;
1198 struct alpha_elf_got_entry
**first_gotent
;
1199 struct alpha_elf_got_entry
*gotent
;
1200 bfd_boolean changed_contents
;
1201 bfd_boolean changed_relocs
;
1202 unsigned char other
;
1205 static bfd_boolean elf64_alpha_relax_with_lituse
1206 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1207 Elf_Internal_Rela
*irel
));
1208 static bfd_vma elf64_alpha_relax_opt_call
1209 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
));
1210 static bfd_boolean elf64_alpha_relax_got_load
1211 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1212 Elf_Internal_Rela
*irel
, unsigned long));
1213 static bfd_boolean elf64_alpha_relax_gprelhilo
1214 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1215 Elf_Internal_Rela
*irel
, bfd_boolean
));
1216 static bfd_boolean elf64_alpha_relax_tls_get_addr
1217 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1218 Elf_Internal_Rela
*irel
, bfd_boolean
));
1219 static bfd_boolean elf64_alpha_relax_section
1220 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
1221 bfd_boolean
*again
));
1223 static Elf_Internal_Rela
*
1224 elf64_alpha_find_reloc_at_ofs (rel
, relend
, offset
, type
)
1225 Elf_Internal_Rela
*rel
, *relend
;
1229 while (rel
< relend
)
1231 if (rel
->r_offset
== offset
1232 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
1240 elf64_alpha_relax_with_lituse (info
, symval
, irel
)
1241 struct alpha_relax_info
*info
;
1243 Elf_Internal_Rela
*irel
;
1245 Elf_Internal_Rela
*urel
, *irelend
= info
->relend
;
1246 int flags
, count
, i
;
1247 bfd_signed_vma disp
;
1250 bfd_boolean lit_reused
= FALSE
;
1251 bfd_boolean all_optimized
= TRUE
;
1252 unsigned int lit_insn
;
1254 lit_insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1255 if (lit_insn
>> 26 != OP_LDQ
)
1257 ((*_bfd_error_handler
)
1258 ("%B: %A+0x%lx: warning: LITERAL relocation against unexpected insn",
1259 info
->abfd
, info
->sec
,
1260 (unsigned long) irel
->r_offset
));
1264 /* Can't relax dynamic symbols. */
1265 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
1268 /* Summarize how this particular LITERAL is used. */
1269 for (urel
= irel
+1, flags
= count
= 0; urel
< irelend
; ++urel
, ++count
)
1271 if (ELF64_R_TYPE (urel
->r_info
) != R_ALPHA_LITUSE
)
1273 if (urel
->r_addend
<= 3)
1274 flags
|= 1 << urel
->r_addend
;
1277 /* A little preparation for the loop... */
1278 disp
= symval
- info
->gp
;
1280 for (urel
= irel
+1, i
= 0; i
< count
; ++i
, ++urel
)
1284 bfd_signed_vma xdisp
;
1286 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ urel
->r_offset
);
1288 switch (urel
->r_addend
)
1290 case LITUSE_ALPHA_ADDR
:
1292 /* This type is really just a placeholder to note that all
1293 uses cannot be optimized, but to still allow some. */
1294 all_optimized
= FALSE
;
1297 case LITUSE_ALPHA_BASE
:
1298 /* We can always optimize 16-bit displacements. */
1300 /* Extract the displacement from the instruction, sign-extending
1301 it if necessary, then test whether it is within 16 or 32 bits
1302 displacement from GP. */
1303 insn_disp
= insn
& 0x0000ffff;
1304 if (insn_disp
& 0x8000)
1305 insn_disp
|= ~0xffff; /* Negative: sign-extend. */
1307 xdisp
= disp
+ insn_disp
;
1308 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x8000 && xdisp
< 0x8000);
1309 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000
1310 && xdisp
< 0x7fff8000);
1314 /* Take the op code and dest from this insn, take the base
1315 register from the literal insn. Leave the offset alone. */
1316 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
1317 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1319 urel
->r_addend
= irel
->r_addend
;
1320 info
->changed_relocs
= TRUE
;
1322 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1323 info
->contents
+ urel
->r_offset
);
1324 info
->changed_contents
= TRUE
;
1327 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1328 else if (fits32
&& !(flags
& ~6))
1330 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1332 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1334 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
1335 bfd_put_32 (info
->abfd
, (bfd_vma
) lit_insn
,
1336 info
->contents
+ irel
->r_offset
);
1338 info
->changed_contents
= TRUE
;
1340 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1342 urel
->r_addend
= irel
->r_addend
;
1343 info
->changed_relocs
= TRUE
;
1346 all_optimized
= FALSE
;
1349 case LITUSE_ALPHA_BYTOFF
:
1350 /* We can always optimize byte instructions. */
1352 /* FIXME: sanity check the insn for byte op. Check that the
1353 literal dest reg is indeed Rb in the byte insn. */
1355 insn
&= ~ (unsigned) 0x001ff000;
1356 insn
|= ((symval
& 7) << 13) | 0x1000;
1358 urel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1360 info
->changed_relocs
= TRUE
;
1362 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1363 info
->contents
+ urel
->r_offset
);
1364 info
->changed_contents
= TRUE
;
1367 case LITUSE_ALPHA_JSR
:
1368 case LITUSE_ALPHA_TLSGD
:
1369 case LITUSE_ALPHA_TLSLDM
:
1371 bfd_vma optdest
, org
;
1372 bfd_signed_vma odisp
;
1374 /* If not zero, place to jump without needing pv. */
1375 optdest
= elf64_alpha_relax_opt_call (info
, symval
);
1376 org
= (info
->sec
->output_section
->vma
1377 + info
->sec
->output_offset
1378 + urel
->r_offset
+ 4);
1379 odisp
= (optdest
? optdest
: symval
) - org
;
1381 if (odisp
>= -0x400000 && odisp
< 0x400000)
1383 Elf_Internal_Rela
*xrel
;
1385 /* Preserve branch prediction call stack when possible. */
1386 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
1387 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
1389 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
1391 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1393 urel
->r_addend
= irel
->r_addend
;
1396 urel
->r_addend
+= optdest
- symval
;
1398 all_optimized
= FALSE
;
1400 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
,
1401 info
->contents
+ urel
->r_offset
);
1403 /* Kill any HINT reloc that might exist for this insn. */
1404 xrel
= (elf64_alpha_find_reloc_at_ofs
1405 (info
->relocs
, info
->relend
, urel
->r_offset
,
1408 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1410 info
->changed_contents
= TRUE
;
1411 info
->changed_relocs
= TRUE
;
1414 all_optimized
= FALSE
;
1416 /* Even if the target is not in range for a direct branch,
1417 if we share a GP, we can eliminate the gp reload. */
1420 Elf_Internal_Rela
*gpdisp
1421 = (elf64_alpha_find_reloc_at_ofs
1422 (info
->relocs
, irelend
, urel
->r_offset
+ 4,
1426 bfd_byte
*p_ldah
= info
->contents
+ gpdisp
->r_offset
;
1427 bfd_byte
*p_lda
= p_ldah
+ gpdisp
->r_addend
;
1428 unsigned int ldah
= bfd_get_32 (info
->abfd
, p_ldah
);
1429 unsigned int lda
= bfd_get_32 (info
->abfd
, p_lda
);
1431 /* Verify that the instruction is "ldah $29,0($26)".
1432 Consider a function that ends in a noreturn call,
1433 and that the next function begins with an ldgp,
1434 and that by accident there is no padding between.
1435 In that case the insn would use $27 as the base. */
1436 if (ldah
== 0x27ba0000 && lda
== 0x23bd0000)
1438 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_ldah
);
1439 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, p_lda
);
1441 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1442 info
->changed_contents
= TRUE
;
1443 info
->changed_relocs
= TRUE
;
1452 /* If all cases were optimized, we can reduce the use count on this
1453 got entry by one, possibly eliminating it. */
1456 if (--info
->gotent
->use_count
== 0)
1458 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
1459 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1461 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1464 /* If the literal instruction is no longer needed (it may have been
1465 reused. We can eliminate it. */
1466 /* ??? For now, I don't want to deal with compacting the section,
1467 so just nop it out. */
1470 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1471 info
->changed_relocs
= TRUE
;
1473 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
,
1474 info
->contents
+ irel
->r_offset
);
1475 info
->changed_contents
= TRUE
;
1483 elf64_alpha_relax_opt_call (info
, symval
)
1484 struct alpha_relax_info
*info
;
1487 /* If the function has the same gp, and we can identify that the
1488 function does not use its function pointer, we can eliminate the
1491 /* If the symbol is marked NOPV, we are being told the function never
1492 needs its procedure value. */
1493 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
1496 /* If the symbol is marked STD_GP, we are being told the function does
1497 a normal ldgp in the first two words. */
1498 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
1501 /* Otherwise, we may be able to identify a GP load in the first two
1502 words, which we can then skip. */
1505 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
1508 /* Load the relocations from the section that the target symbol is in. */
1509 if (info
->sec
== info
->tsec
)
1511 tsec_relocs
= info
->relocs
;
1512 tsec_relend
= info
->relend
;
1517 tsec_relocs
= (_bfd_elf_link_read_relocs
1518 (info
->abfd
, info
->tsec
, (PTR
) NULL
,
1519 (Elf_Internal_Rela
*) NULL
,
1520 info
->link_info
->keep_memory
));
1521 if (tsec_relocs
== NULL
)
1523 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
1524 tsec_free
= (info
->link_info
->keep_memory
? NULL
: tsec_relocs
);
1527 /* Recover the symbol's offset within the section. */
1528 ofs
= (symval
- info
->tsec
->output_section
->vma
1529 - info
->tsec
->output_offset
);
1531 /* Look for a GPDISP reloc. */
1532 gpdisp
= (elf64_alpha_find_reloc_at_ofs
1533 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
1535 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
1545 /* We've now determined that we can skip an initial gp load. Verify
1546 that the call and the target use the same gp. */
1547 if (info
->link_info
->hash
->creator
!= info
->tsec
->owner
->xvec
1548 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
1555 elf64_alpha_relax_got_load (info
, symval
, irel
, r_type
)
1556 struct alpha_relax_info
*info
;
1558 Elf_Internal_Rela
*irel
;
1559 unsigned long r_type
;
1562 bfd_signed_vma disp
;
1564 /* Get the instruction. */
1565 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1567 if (insn
>> 26 != OP_LDQ
)
1569 reloc_howto_type
*howto
= elf64_alpha_howto_table
+ r_type
;
1570 ((*_bfd_error_handler
)
1571 ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
1572 info
->abfd
, info
->sec
,
1573 (unsigned long) irel
->r_offset
, howto
->name
));
1577 /* Can't relax dynamic symbols. */
1578 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
1581 /* Can't use local-exec relocations in shared libraries. */
1582 if (r_type
== R_ALPHA_GOTTPREL
&& info
->link_info
->shared
)
1585 if (r_type
== R_ALPHA_LITERAL
)
1586 disp
= symval
- info
->gp
;
1589 bfd_vma dtp_base
, tp_base
;
1591 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
1592 dtp_base
= alpha_get_dtprel_base (info
->link_info
);
1593 tp_base
= alpha_get_tprel_base (info
->link_info
);
1594 disp
= symval
- (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
1597 if (disp
< -0x8000 || disp
>= 0x8000)
1600 /* Exchange LDQ for LDA. In the case of the TLS relocs, we're loading
1601 a constant, so force the base register to be $31. */
1602 if (r_type
== R_ALPHA_LITERAL
)
1603 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
1605 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
1606 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, info
->contents
+ irel
->r_offset
);
1607 info
->changed_contents
= TRUE
;
1609 /* Reduce the use count on this got entry by one, possibly
1611 if (--info
->gotent
->use_count
== 0)
1613 int sz
= alpha_got_entry_size (r_type
);
1614 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1616 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1619 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
1622 case R_ALPHA_LITERAL
:
1623 r_type
= R_ALPHA_GPREL16
;
1625 case R_ALPHA_GOTDTPREL
:
1626 r_type
= R_ALPHA_DTPREL16
;
1628 case R_ALPHA_GOTTPREL
:
1629 r_type
= R_ALPHA_TPREL16
;
1636 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), r_type
);
1637 info
->changed_relocs
= TRUE
;
1639 /* ??? Search forward through this basic block looking for insns
1640 that use the target register. Stop after an insn modifying the
1641 register is seen, or after a branch or call.
1643 Any such memory load insn may be substituted by a load directly
1644 off the GP. This allows the memory load insn to be issued before
1645 the calculated GP register would otherwise be ready.
1647 Any such jsr insn can be replaced by a bsr if it is in range.
1649 This would mean that we'd have to _add_ relocations, the pain of
1650 which gives one pause. */
1656 elf64_alpha_relax_gprelhilo (info
, symval
, irel
, hi
)
1657 struct alpha_relax_info
*info
;
1659 Elf_Internal_Rela
*irel
;
1663 bfd_signed_vma disp
;
1664 bfd_byte
*pos
= info
->contents
+ irel
->r_offset
;
1666 /* ??? This assumes that the compiler doesn't render
1670 ldah t, array(gp) !gprelhigh
1672 ldq r, array(t) !gprellow
1674 which would indeed be the most efficient way to implement this. */
1678 disp
= symval
- info
->gp
;
1679 if (disp
< -0x8000 || disp
>= 0x8000)
1684 /* Nop out the high instruction. */
1686 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
);
1687 info
->changed_contents
= TRUE
;
1689 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1691 info
->changed_relocs
= TRUE
;
1695 /* Adjust the low instruction to reference GP directly. */
1697 insn
= bfd_get_32 (info
->abfd
, pos
);
1698 insn
= (insn
& 0xffe00000) | (29 << 16);
1699 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
);
1700 info
->changed_contents
= TRUE
;
1702 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1704 info
->changed_relocs
= TRUE
;
1711 elf64_alpha_relax_tls_get_addr (info
, symval
, irel
, is_gd
)
1712 struct alpha_relax_info
*info
;
1714 Elf_Internal_Rela
*irel
;
1719 Elf_Internal_Rela
*gpdisp
, *hint
;
1720 bfd_boolean dynamic
, use_gottprel
, pos1_unusable
;
1721 unsigned long new_symndx
;
1723 dynamic
= alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
);
1725 /* If a TLS symbol is accessed using IE at least once, there is no point
1726 to use dynamic model for it. */
1727 if (is_gd
&& info
->h
&& (info
->h
->flags
& ALPHA_ELF_LINK_HASH_TLS_IE
))
1730 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
1731 then we might as well relax to IE. */
1732 else if (info
->link_info
->shared
&& !dynamic
1733 && (info
->link_info
->flags
& DF_STATIC_TLS
))
1736 /* Otherwise we must be building an executable to do anything. */
1737 else if (info
->link_info
->shared
)
1740 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
1741 the matching LITUSE_TLS relocations. */
1742 if (irel
+ 2 >= info
->relend
)
1744 if (ELF64_R_TYPE (irel
[1].r_info
) != R_ALPHA_LITERAL
1745 || ELF64_R_TYPE (irel
[2].r_info
) != R_ALPHA_LITUSE
1746 || irel
[2].r_addend
!= (is_gd
? LITUSE_ALPHA_TLSGD
: LITUSE_ALPHA_TLSLDM
))
1749 /* There must be a GPDISP relocation positioned immediately after the
1750 LITUSE relocation. */
1751 gpdisp
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
1752 irel
[2].r_offset
+ 4, R_ALPHA_GPDISP
);
1756 pos
[0] = info
->contents
+ irel
[0].r_offset
;
1757 pos
[1] = info
->contents
+ irel
[1].r_offset
;
1758 pos
[2] = info
->contents
+ irel
[2].r_offset
;
1759 pos
[3] = info
->contents
+ gpdisp
->r_offset
;
1760 pos
[4] = pos
[3] + gpdisp
->r_addend
;
1761 pos1_unusable
= FALSE
;
1763 /* Generally, the positions are not allowed to be out of order, lest the
1764 modified insn sequence have different register lifetimes. We can make
1765 an exception when pos 1 is adjacent to pos 0. */
1766 if (pos
[1] + 4 == pos
[0])
1768 bfd_byte
*tmp
= pos
[0];
1772 else if (pos
[1] < pos
[0])
1773 pos1_unusable
= TRUE
;
1774 if (pos
[1] >= pos
[2] || pos
[2] >= pos
[3])
1777 /* Reduce the use count on the LITERAL relocation. Do this before we
1778 smash the symndx when we adjust the relocations below. */
1780 struct alpha_elf_got_entry
*lit_gotent
;
1781 struct alpha_elf_link_hash_entry
*lit_h
;
1784 BFD_ASSERT (ELF64_R_SYM (irel
[1].r_info
) >= info
->symtab_hdr
->sh_info
);
1785 indx
= ELF64_R_SYM (irel
[1].r_info
) - info
->symtab_hdr
->sh_info
;
1786 lit_h
= alpha_elf_sym_hashes (info
->abfd
)[indx
];
1788 while (lit_h
->root
.root
.type
== bfd_link_hash_indirect
1789 || lit_h
->root
.root
.type
== bfd_link_hash_warning
)
1790 lit_h
= (struct alpha_elf_link_hash_entry
*) lit_h
->root
.root
.u
.i
.link
;
1792 for (lit_gotent
= lit_h
->got_entries
; lit_gotent
;
1793 lit_gotent
= lit_gotent
->next
)
1794 if (lit_gotent
->gotobj
== info
->gotobj
1795 && lit_gotent
->reloc_type
== R_ALPHA_LITERAL
1796 && lit_gotent
->addend
== irel
[1].r_addend
)
1798 BFD_ASSERT (lit_gotent
);
1800 if (--lit_gotent
->use_count
== 0)
1802 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
1803 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1809 lda $16,x($gp) !tlsgd!1
1810 ldq $27,__tls_get_addr($gp) !literal!1
1811 jsr $26,($27)__tls_get_addr !lituse_tlsgd!1
1812 ldah $29,0($26) !gpdisp!2
1813 lda $29,0($29) !gpdisp!2
1815 ldq $16,x($gp) !gottprel
1820 or the first pair to
1821 lda $16,x($gp) !tprel
1824 ldah $16,x($gp) !tprelhi
1825 lda $16,x($16) !tprello
1829 use_gottprel
= FALSE
;
1830 new_symndx
= is_gd
? ELF64_R_SYM (irel
->r_info
) : 0;
1831 switch (!dynamic
&& !info
->link_info
->shared
)
1836 bfd_signed_vma disp
;
1838 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
1839 tp_base
= alpha_get_tprel_base (info
->link_info
);
1840 disp
= symval
- tp_base
;
1842 if (disp
>= -0x8000 && disp
< 0x8000)
1844 insn
= (OP_LDA
<< 26) | (16 << 21) | (31 << 16);
1845 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1846 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
1848 irel
[0].r_offset
= pos
[0] - info
->contents
;
1849 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPREL16
);
1850 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1853 else if (disp
>= -(bfd_signed_vma
) 0x80000000
1854 && disp
< (bfd_signed_vma
) 0x7fff8000
1857 insn
= (OP_LDAH
<< 26) | (16 << 21) | (31 << 16);
1858 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1859 insn
= (OP_LDA
<< 26) | (16 << 21) | (16 << 16);
1860 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[1]);
1862 irel
[0].r_offset
= pos
[0] - info
->contents
;
1863 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELHI
);
1864 irel
[1].r_offset
= pos
[1] - info
->contents
;
1865 irel
[1].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELLO
);
1872 use_gottprel
= TRUE
;
1874 insn
= (OP_LDQ
<< 26) | (16 << 21) | (29 << 16);
1875 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
1876 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
1878 irel
[0].r_offset
= pos
[0] - info
->contents
;
1879 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_GOTTPREL
);
1880 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1884 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_RDUNIQ
, pos
[2]);
1886 insn
= INSN_ADDQ
| (16 << 21) | (0 << 16) | (0 << 0);
1887 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[3]);
1889 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[4]);
1891 irel
[2].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1892 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1894 hint
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
1895 irel
[2].r_offset
, R_ALPHA_HINT
);
1897 hint
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1899 info
->changed_contents
= TRUE
;
1900 info
->changed_relocs
= TRUE
;
1902 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
1903 if (--info
->gotent
->use_count
== 0)
1905 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
1906 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
1908 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
1911 /* If we've switched to a GOTTPREL relocation, increment the reference
1912 count on that got entry. */
1915 struct alpha_elf_got_entry
*tprel_gotent
;
1917 for (tprel_gotent
= *info
->first_gotent
; tprel_gotent
;
1918 tprel_gotent
= tprel_gotent
->next
)
1919 if (tprel_gotent
->gotobj
== info
->gotobj
1920 && tprel_gotent
->reloc_type
== R_ALPHA_GOTTPREL
1921 && tprel_gotent
->addend
== irel
->r_addend
)
1924 tprel_gotent
->use_count
++;
1927 if (info
->gotent
->use_count
== 0)
1928 tprel_gotent
= info
->gotent
;
1931 tprel_gotent
= (struct alpha_elf_got_entry
*)
1932 bfd_alloc (info
->abfd
, sizeof (struct alpha_elf_got_entry
));
1936 tprel_gotent
->next
= *info
->first_gotent
;
1937 *info
->first_gotent
= tprel_gotent
;
1939 tprel_gotent
->gotobj
= info
->gotobj
;
1940 tprel_gotent
->addend
= irel
->r_addend
;
1941 tprel_gotent
->got_offset
= -1;
1942 tprel_gotent
->reloc_done
= 0;
1943 tprel_gotent
->reloc_xlated
= 0;
1946 tprel_gotent
->use_count
= 1;
1947 tprel_gotent
->reloc_type
= R_ALPHA_GOTTPREL
;
1955 elf64_alpha_relax_section (abfd
, sec
, link_info
, again
)
1958 struct bfd_link_info
*link_info
;
1961 Elf_Internal_Shdr
*symtab_hdr
;
1962 Elf_Internal_Rela
*internal_relocs
;
1963 Elf_Internal_Rela
*irel
, *irelend
;
1964 Elf_Internal_Sym
*isymbuf
= NULL
;
1965 struct alpha_elf_got_entry
**local_got_entries
;
1966 struct alpha_relax_info info
;
1968 /* We are not currently changing any sizes, so only one pass. */
1971 if (link_info
->relocatable
1972 || (sec
->flags
& SEC_RELOC
) == 0
1973 || sec
->reloc_count
== 0)
1976 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1977 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1979 /* Load the relocations for this section. */
1980 internal_relocs
= (_bfd_elf_link_read_relocs
1981 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1982 link_info
->keep_memory
));
1983 if (internal_relocs
== NULL
)
1986 memset(&info
, 0, sizeof (info
));
1989 info
.link_info
= link_info
;
1990 info
.symtab_hdr
= symtab_hdr
;
1991 info
.relocs
= internal_relocs
;
1992 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
1994 /* Find the GP for this object. Do not store the result back via
1995 _bfd_set_gp_value, since this could change again before final. */
1996 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
1999 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
2000 info
.gp
= (sgot
->output_section
->vma
2001 + sgot
->output_offset
2005 /* Get the section contents. */
2006 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2007 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
2010 if (!bfd_malloc_and_get_section (abfd
, sec
, &info
.contents
))
2014 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2017 struct alpha_elf_got_entry
*gotent
;
2018 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
2019 unsigned long r_symndx
= ELF64_R_SYM (irel
->r_info
);
2021 /* Early exit for unhandled or unrelaxable relocations. */
2024 case R_ALPHA_LITERAL
:
2025 case R_ALPHA_GPRELHIGH
:
2026 case R_ALPHA_GPRELLOW
:
2027 case R_ALPHA_GOTDTPREL
:
2028 case R_ALPHA_GOTTPREL
:
2032 case R_ALPHA_TLSLDM
:
2033 /* The symbol for a TLSLDM reloc is ignored. Collapse the
2034 reloc to the 0 symbol so that they all match. */
2042 /* Get the value of the symbol referred to by the reloc. */
2043 if (r_symndx
< symtab_hdr
->sh_info
)
2045 /* A local symbol. */
2046 Elf_Internal_Sym
*isym
;
2048 /* Read this BFD's local symbols. */
2049 if (isymbuf
== NULL
)
2051 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2052 if (isymbuf
== NULL
)
2053 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2054 symtab_hdr
->sh_info
, 0,
2056 if (isymbuf
== NULL
)
2060 isym
= isymbuf
+ r_symndx
;
2062 /* Given the symbol for a TLSLDM reloc is ignored, this also
2063 means forcing the symbol value to the tp base. */
2064 if (r_type
== R_ALPHA_TLSLDM
)
2066 info
.tsec
= bfd_abs_section_ptr
;
2067 symval
= alpha_get_tprel_base (info
.link_info
);
2071 symval
= isym
->st_value
;
2072 if (isym
->st_shndx
== SHN_UNDEF
)
2074 else if (isym
->st_shndx
== SHN_ABS
)
2075 info
.tsec
= bfd_abs_section_ptr
;
2076 else if (isym
->st_shndx
== SHN_COMMON
)
2077 info
.tsec
= bfd_com_section_ptr
;
2079 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2083 info
.other
= isym
->st_other
;
2084 if (local_got_entries
)
2085 info
.first_gotent
= &local_got_entries
[r_symndx
];
2088 info
.first_gotent
= &info
.gotent
;
2095 struct alpha_elf_link_hash_entry
*h
;
2097 indx
= r_symndx
- symtab_hdr
->sh_info
;
2098 h
= alpha_elf_sym_hashes (abfd
)[indx
];
2099 BFD_ASSERT (h
!= NULL
);
2101 while (h
->root
.root
.type
== bfd_link_hash_indirect
2102 || h
->root
.root
.type
== bfd_link_hash_warning
)
2103 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2105 /* If the symbol is undefined, we can't do anything with it. */
2106 if (h
->root
.root
.type
== bfd_link_hash_undefweak
2107 || h
->root
.root
.type
== bfd_link_hash_undefined
)
2110 /* If the symbol isn't defined in the current module, again
2111 we can't do anything. */
2112 if (!h
->root
.def_regular
)
2114 /* Except for TLSGD relocs, which can sometimes be
2115 relaxed to GOTTPREL relocs. */
2116 if (r_type
!= R_ALPHA_TLSGD
)
2118 info
.tsec
= bfd_abs_section_ptr
;
2123 info
.tsec
= h
->root
.root
.u
.def
.section
;
2124 symval
= h
->root
.root
.u
.def
.value
;
2128 info
.other
= h
->root
.other
;
2129 info
.first_gotent
= &h
->got_entries
;
2132 /* Search for the got entry to be used by this relocation. */
2133 for (gotent
= *info
.first_gotent
; gotent
; gotent
= gotent
->next
)
2134 if (gotent
->gotobj
== info
.gotobj
2135 && gotent
->reloc_type
== r_type
2136 && gotent
->addend
== irel
->r_addend
)
2138 info
.gotent
= gotent
;
2140 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
2141 symval
+= irel
->r_addend
;
2145 case R_ALPHA_LITERAL
:
2146 BFD_ASSERT(info
.gotent
!= NULL
);
2148 /* If there exist LITUSE relocations immediately following, this
2149 opens up all sorts of interesting optimizations, because we
2150 now know every location that this address load is used. */
2151 if (irel
+1 < irelend
2152 && ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
2154 if (!elf64_alpha_relax_with_lituse (&info
, symval
, irel
))
2159 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
2164 case R_ALPHA_GPRELHIGH
:
2165 case R_ALPHA_GPRELLOW
:
2166 if (!elf64_alpha_relax_gprelhilo (&info
, symval
, irel
,
2167 r_type
== R_ALPHA_GPRELHIGH
))
2171 case R_ALPHA_GOTDTPREL
:
2172 case R_ALPHA_GOTTPREL
:
2173 BFD_ASSERT(info
.gotent
!= NULL
);
2174 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
2179 case R_ALPHA_TLSLDM
:
2180 BFD_ASSERT(info
.gotent
!= NULL
);
2181 if (!elf64_alpha_relax_tls_get_addr (&info
, symval
, irel
,
2182 r_type
== R_ALPHA_TLSGD
))
2188 if (!elf64_alpha_size_plt_section (link_info
))
2190 if (!elf64_alpha_size_got_sections (link_info
))
2192 if (!elf64_alpha_size_rela_got_section (link_info
))
2196 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2198 if (!link_info
->keep_memory
)
2202 /* Cache the symbols for elf_link_input_bfd. */
2203 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2207 if (info
.contents
!= NULL
2208 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
2210 if (!info
.changed_contents
&& !link_info
->keep_memory
)
2211 free (info
.contents
);
2214 /* Cache the section contents for elf_link_input_bfd. */
2215 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
2219 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2221 if (!info
.changed_relocs
)
2222 free (internal_relocs
);
2224 elf_section_data (sec
)->relocs
= internal_relocs
;
2227 *again
= info
.changed_contents
|| info
.changed_relocs
;
2233 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2235 if (info
.contents
!= NULL
2236 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
2237 free (info
.contents
);
2238 if (internal_relocs
!= NULL
2239 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2240 free (internal_relocs
);
2245 #define PLT_HEADER_SIZE 32
2246 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
2247 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
2248 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
2249 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
2251 #define PLT_ENTRY_SIZE 12
2252 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
2253 #define PLT_ENTRY_WORD2 0
2254 #define PLT_ENTRY_WORD3 0
2256 #define MAX_GOT_SIZE (64*1024)
2258 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
2260 /* Handle an Alpha specific section when reading an object file. This
2261 is called when bfd_section_from_shdr finds a section with an unknown
2263 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
2267 elf64_alpha_section_from_shdr (bfd
*abfd
,
2268 Elf_Internal_Shdr
*hdr
,
2274 /* There ought to be a place to keep ELF backend specific flags, but
2275 at the moment there isn't one. We just keep track of the
2276 sections by their name, instead. Fortunately, the ABI gives
2277 suggested names for all the MIPS specific sections, so we will
2278 probably get away with this. */
2279 switch (hdr
->sh_type
)
2281 case SHT_ALPHA_DEBUG
:
2282 if (strcmp (name
, ".mdebug") != 0)
2289 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
2291 newsect
= hdr
->bfd_section
;
2293 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
2295 if (! bfd_set_section_flags (abfd
, newsect
,
2296 (bfd_get_section_flags (abfd
, newsect
)
2304 /* Convert Alpha specific section flags to bfd internal section flags. */
2307 elf64_alpha_section_flags (flags
, hdr
)
2309 const Elf_Internal_Shdr
*hdr
;
2311 if (hdr
->sh_flags
& SHF_ALPHA_GPREL
)
2312 *flags
|= SEC_SMALL_DATA
;
2317 /* Set the correct type for an Alpha ELF section. We do this by the
2318 section name, which is a hack, but ought to work. */
2321 elf64_alpha_fake_sections (abfd
, hdr
, sec
)
2323 Elf_Internal_Shdr
*hdr
;
2326 register const char *name
;
2328 name
= bfd_get_section_name (abfd
, sec
);
2330 if (strcmp (name
, ".mdebug") == 0)
2332 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
2333 /* In a shared object on Irix 5.3, the .mdebug section has an
2334 entsize of 0. FIXME: Does this matter? */
2335 if ((abfd
->flags
& DYNAMIC
) != 0 )
2336 hdr
->sh_entsize
= 0;
2338 hdr
->sh_entsize
= 1;
2340 else if ((sec
->flags
& SEC_SMALL_DATA
)
2341 || strcmp (name
, ".sdata") == 0
2342 || strcmp (name
, ".sbss") == 0
2343 || strcmp (name
, ".lit4") == 0
2344 || strcmp (name
, ".lit8") == 0)
2345 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
2350 /* Hook called by the linker routine which adds symbols from an object
2351 file. We use it to put .comm items in .sbss, and not .bss. */
2354 elf64_alpha_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
2356 struct bfd_link_info
*info
;
2357 Elf_Internal_Sym
*sym
;
2358 const char **namep ATTRIBUTE_UNUSED
;
2359 flagword
*flagsp ATTRIBUTE_UNUSED
;
2363 if (sym
->st_shndx
== SHN_COMMON
2364 && !info
->relocatable
2365 && sym
->st_size
<= elf_gp_size (abfd
))
2367 /* Common symbols less than or equal to -G nn bytes are
2368 automatically put into .sbss. */
2370 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
2374 scomm
= bfd_make_section (abfd
, ".scommon");
2376 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
2378 | SEC_LINKER_CREATED
)))
2383 *valp
= sym
->st_size
;
2389 /* Create the .got section. */
2392 elf64_alpha_create_got_section(abfd
, info
)
2394 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2398 if ((s
= bfd_get_section_by_name (abfd
, ".got")))
2400 /* Check for a non-linker created .got? */
2401 if (alpha_elf_tdata (abfd
)->got
== NULL
)
2402 alpha_elf_tdata (abfd
)->got
= s
;
2406 s
= bfd_make_section (abfd
, ".got");
2408 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2411 | SEC_LINKER_CREATED
))
2412 || !bfd_set_section_alignment (abfd
, s
, 3))
2415 alpha_elf_tdata (abfd
)->got
= s
;
2420 /* Create all the dynamic sections. */
2423 elf64_alpha_create_dynamic_sections (abfd
, info
)
2425 struct bfd_link_info
*info
;
2428 struct elf_link_hash_entry
*h
;
2429 struct bfd_link_hash_entry
*bh
;
2431 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2433 s
= bfd_make_section (abfd
, ".plt");
2435 || ! bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2438 | SEC_LINKER_CREATED
2440 || ! bfd_set_section_alignment (abfd
, s
, 3))
2443 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2446 if (! (_bfd_generic_link_add_one_symbol
2447 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
2448 (bfd_vma
) 0, (const char *) NULL
, FALSE
,
2449 get_elf_backend_data (abfd
)->collect
, &bh
)))
2451 h
= (struct elf_link_hash_entry
*) bh
;
2453 h
->type
= STT_OBJECT
;
2456 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2459 s
= bfd_make_section (abfd
, ".rela.plt");
2461 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2464 | SEC_LINKER_CREATED
2466 || ! bfd_set_section_alignment (abfd
, s
, 3))
2469 /* We may or may not have created a .got section for this object, but
2470 we definitely havn't done the rest of the work. */
2472 if (!elf64_alpha_create_got_section (abfd
, info
))
2475 s
= bfd_make_section(abfd
, ".rela.got");
2477 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
2480 | SEC_LINKER_CREATED
2482 || !bfd_set_section_alignment (abfd
, s
, 3))
2485 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2486 dynobj's .got section. We don't do this in the linker script
2487 because we don't want to define the symbol if we are not creating
2488 a global offset table. */
2490 if (!(_bfd_generic_link_add_one_symbol
2491 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
,
2492 alpha_elf_tdata(abfd
)->got
, (bfd_vma
) 0, (const char *) NULL
,
2493 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
2495 h
= (struct elf_link_hash_entry
*) bh
;
2497 h
->type
= STT_OBJECT
;
2500 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
2503 elf_hash_table (info
)->hgot
= h
;
2508 /* Read ECOFF debugging information from a .mdebug section into a
2509 ecoff_debug_info structure. */
2512 elf64_alpha_read_ecoff_info (abfd
, section
, debug
)
2515 struct ecoff_debug_info
*debug
;
2518 const struct ecoff_debug_swap
*swap
;
2519 char *ext_hdr
= NULL
;
2521 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2522 memset (debug
, 0, sizeof (*debug
));
2524 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
2525 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
2528 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
2529 swap
->external_hdr_size
))
2532 symhdr
= &debug
->symbolic_header
;
2533 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
2535 /* The symbolic header contains absolute file offsets and sizes to
2537 #define READ(ptr, offset, count, size, type) \
2538 if (symhdr->count == 0) \
2539 debug->ptr = NULL; \
2542 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2543 debug->ptr = (type) bfd_malloc (amt); \
2544 if (debug->ptr == NULL) \
2545 goto error_return; \
2546 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2547 || bfd_bread (debug->ptr, amt, abfd) != amt) \
2548 goto error_return; \
2551 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2552 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2553 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2554 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2555 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2556 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2558 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2559 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2560 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2561 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2562 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2570 if (ext_hdr
!= NULL
)
2572 if (debug
->line
!= NULL
)
2574 if (debug
->external_dnr
!= NULL
)
2575 free (debug
->external_dnr
);
2576 if (debug
->external_pdr
!= NULL
)
2577 free (debug
->external_pdr
);
2578 if (debug
->external_sym
!= NULL
)
2579 free (debug
->external_sym
);
2580 if (debug
->external_opt
!= NULL
)
2581 free (debug
->external_opt
);
2582 if (debug
->external_aux
!= NULL
)
2583 free (debug
->external_aux
);
2584 if (debug
->ss
!= NULL
)
2586 if (debug
->ssext
!= NULL
)
2587 free (debug
->ssext
);
2588 if (debug
->external_fdr
!= NULL
)
2589 free (debug
->external_fdr
);
2590 if (debug
->external_rfd
!= NULL
)
2591 free (debug
->external_rfd
);
2592 if (debug
->external_ext
!= NULL
)
2593 free (debug
->external_ext
);
2597 /* Alpha ELF local labels start with '$'. */
2600 elf64_alpha_is_local_label_name (abfd
, name
)
2601 bfd
*abfd ATTRIBUTE_UNUSED
;
2604 return name
[0] == '$';
2607 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2608 routine in order to handle the ECOFF debugging information. We
2609 still call this mips_elf_find_line because of the slot
2610 find_line_info in elf_obj_tdata is declared that way. */
2612 struct mips_elf_find_line
2614 struct ecoff_debug_info d
;
2615 struct ecoff_find_line i
;
2619 elf64_alpha_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2620 functionname_ptr
, line_ptr
)
2625 const char **filename_ptr
;
2626 const char **functionname_ptr
;
2627 unsigned int *line_ptr
;
2631 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2632 filename_ptr
, functionname_ptr
,
2634 &elf_tdata (abfd
)->dwarf2_find_line_info
))
2637 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2641 struct mips_elf_find_line
*fi
;
2642 const struct ecoff_debug_swap
* const swap
=
2643 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2645 /* If we are called during a link, alpha_elf_final_link may have
2646 cleared the SEC_HAS_CONTENTS field. We force it back on here
2647 if appropriate (which it normally will be). */
2648 origflags
= msec
->flags
;
2649 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2650 msec
->flags
|= SEC_HAS_CONTENTS
;
2652 fi
= elf_tdata (abfd
)->find_line_info
;
2655 bfd_size_type external_fdr_size
;
2658 struct fdr
*fdr_ptr
;
2659 bfd_size_type amt
= sizeof (struct mips_elf_find_line
);
2661 fi
= (struct mips_elf_find_line
*) bfd_zalloc (abfd
, amt
);
2664 msec
->flags
= origflags
;
2668 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
2670 msec
->flags
= origflags
;
2674 /* Swap in the FDR information. */
2675 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
2676 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
2677 if (fi
->d
.fdr
== NULL
)
2679 msec
->flags
= origflags
;
2682 external_fdr_size
= swap
->external_fdr_size
;
2683 fdr_ptr
= fi
->d
.fdr
;
2684 fraw_src
= (char *) fi
->d
.external_fdr
;
2685 fraw_end
= (fraw_src
2686 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2687 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2688 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2690 elf_tdata (abfd
)->find_line_info
= fi
;
2692 /* Note that we don't bother to ever free this information.
2693 find_nearest_line is either called all the time, as in
2694 objdump -l, so the information should be saved, or it is
2695 rarely called, as in ld error messages, so the memory
2696 wasted is unimportant. Still, it would probably be a
2697 good idea for free_cached_info to throw it away. */
2700 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2701 &fi
->i
, filename_ptr
, functionname_ptr
,
2704 msec
->flags
= origflags
;
2708 msec
->flags
= origflags
;
2711 /* Fall back on the generic ELF find_nearest_line routine. */
2713 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2714 filename_ptr
, functionname_ptr
,
2718 /* Structure used to pass information to alpha_elf_output_extsym. */
2723 struct bfd_link_info
*info
;
2724 struct ecoff_debug_info
*debug
;
2725 const struct ecoff_debug_swap
*swap
;
2730 elf64_alpha_output_extsym (h
, data
)
2731 struct alpha_elf_link_hash_entry
*h
;
2734 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2736 asection
*sec
, *output_section
;
2738 if (h
->root
.root
.type
== bfd_link_hash_warning
)
2739 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2741 if (h
->root
.indx
== -2)
2743 else if ((h
->root
.def_dynamic
2744 || h
->root
.ref_dynamic
2745 || h
->root
.root
.type
== bfd_link_hash_new
)
2746 && !h
->root
.def_regular
2747 && !h
->root
.ref_regular
)
2749 else if (einfo
->info
->strip
== strip_all
2750 || (einfo
->info
->strip
== strip_some
2751 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2752 h
->root
.root
.root
.string
,
2753 FALSE
, FALSE
) == NULL
))
2761 if (h
->esym
.ifd
== -2)
2764 h
->esym
.cobol_main
= 0;
2765 h
->esym
.weakext
= 0;
2766 h
->esym
.reserved
= 0;
2767 h
->esym
.ifd
= ifdNil
;
2768 h
->esym
.asym
.value
= 0;
2769 h
->esym
.asym
.st
= stGlobal
;
2771 if (h
->root
.root
.type
!= bfd_link_hash_defined
2772 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2773 h
->esym
.asym
.sc
= scAbs
;
2778 sec
= h
->root
.root
.u
.def
.section
;
2779 output_section
= sec
->output_section
;
2781 /* When making a shared library and symbol h is the one from
2782 the another shared library, OUTPUT_SECTION may be null. */
2783 if (output_section
== NULL
)
2784 h
->esym
.asym
.sc
= scUndefined
;
2787 name
= bfd_section_name (output_section
->owner
, output_section
);
2789 if (strcmp (name
, ".text") == 0)
2790 h
->esym
.asym
.sc
= scText
;
2791 else if (strcmp (name
, ".data") == 0)
2792 h
->esym
.asym
.sc
= scData
;
2793 else if (strcmp (name
, ".sdata") == 0)
2794 h
->esym
.asym
.sc
= scSData
;
2795 else if (strcmp (name
, ".rodata") == 0
2796 || strcmp (name
, ".rdata") == 0)
2797 h
->esym
.asym
.sc
= scRData
;
2798 else if (strcmp (name
, ".bss") == 0)
2799 h
->esym
.asym
.sc
= scBss
;
2800 else if (strcmp (name
, ".sbss") == 0)
2801 h
->esym
.asym
.sc
= scSBss
;
2802 else if (strcmp (name
, ".init") == 0)
2803 h
->esym
.asym
.sc
= scInit
;
2804 else if (strcmp (name
, ".fini") == 0)
2805 h
->esym
.asym
.sc
= scFini
;
2807 h
->esym
.asym
.sc
= scAbs
;
2811 h
->esym
.asym
.reserved
= 0;
2812 h
->esym
.asym
.index
= indexNil
;
2815 if (h
->root
.root
.type
== bfd_link_hash_common
)
2816 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2817 else if (h
->root
.root
.type
== bfd_link_hash_defined
2818 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2820 if (h
->esym
.asym
.sc
== scCommon
)
2821 h
->esym
.asym
.sc
= scBss
;
2822 else if (h
->esym
.asym
.sc
== scSCommon
)
2823 h
->esym
.asym
.sc
= scSBss
;
2825 sec
= h
->root
.root
.u
.def
.section
;
2826 output_section
= sec
->output_section
;
2827 if (output_section
!= NULL
)
2828 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2829 + sec
->output_offset
2830 + output_section
->vma
);
2832 h
->esym
.asym
.value
= 0;
2834 else if (h
->root
.needs_plt
)
2836 /* Set type and value for a symbol with a function stub. */
2837 h
->esym
.asym
.st
= stProc
;
2838 sec
= bfd_get_section_by_name (einfo
->abfd
, ".plt");
2840 h
->esym
.asym
.value
= 0;
2843 output_section
= sec
->output_section
;
2844 if (output_section
!= NULL
)
2845 h
->esym
.asym
.value
= (h
->root
.plt
.offset
2846 + sec
->output_offset
2847 + output_section
->vma
);
2849 h
->esym
.asym
.value
= 0;
2853 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2854 h
->root
.root
.root
.string
,
2857 einfo
->failed
= TRUE
;
2864 /* Search for and possibly create a got entry. */
2866 static struct alpha_elf_got_entry
*
2867 get_got_entry (abfd
, h
, r_type
, r_symndx
, r_addend
)
2869 struct alpha_elf_link_hash_entry
*h
;
2870 unsigned long r_type
, r_symndx
;
2873 struct alpha_elf_got_entry
*gotent
;
2874 struct alpha_elf_got_entry
**slot
;
2877 slot
= &h
->got_entries
;
2880 /* This is a local .got entry -- record for merge. */
2882 struct alpha_elf_got_entry
**local_got_entries
;
2884 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2885 if (!local_got_entries
)
2888 Elf_Internal_Shdr
*symtab_hdr
;
2890 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2891 size
= symtab_hdr
->sh_info
;
2892 size
*= sizeof (struct alpha_elf_got_entry
*);
2895 = (struct alpha_elf_got_entry
**) bfd_zalloc (abfd
, size
);
2896 if (!local_got_entries
)
2899 alpha_elf_tdata (abfd
)->local_got_entries
= local_got_entries
;
2902 slot
= &local_got_entries
[r_symndx
];
2905 for (gotent
= *slot
; gotent
; gotent
= gotent
->next
)
2906 if (gotent
->gotobj
== abfd
2907 && gotent
->reloc_type
== r_type
2908 && gotent
->addend
== r_addend
)
2916 amt
= sizeof (struct alpha_elf_got_entry
);
2917 gotent
= (struct alpha_elf_got_entry
*) bfd_alloc (abfd
, amt
);
2921 gotent
->gotobj
= abfd
;
2922 gotent
->addend
= r_addend
;
2923 gotent
->got_offset
= -1;
2924 gotent
->use_count
= 1;
2925 gotent
->reloc_type
= r_type
;
2926 gotent
->reloc_done
= 0;
2927 gotent
->reloc_xlated
= 0;
2929 gotent
->next
= *slot
;
2932 entry_size
= alpha_got_entry_size (r_type
);
2933 alpha_elf_tdata (abfd
)->total_got_size
+= entry_size
;
2935 alpha_elf_tdata(abfd
)->local_got_size
+= entry_size
;
2938 gotent
->use_count
+= 1;
2943 /* Handle dynamic relocations when doing an Alpha ELF link. */
2946 elf64_alpha_check_relocs (abfd
, info
, sec
, relocs
)
2948 struct bfd_link_info
*info
;
2950 const Elf_Internal_Rela
*relocs
;
2954 const char *rel_sec_name
;
2955 Elf_Internal_Shdr
*symtab_hdr
;
2956 struct alpha_elf_link_hash_entry
**sym_hashes
;
2957 const Elf_Internal_Rela
*rel
, *relend
;
2958 bfd_boolean got_created
;
2961 if (info
->relocatable
)
2964 dynobj
= elf_hash_table(info
)->dynobj
;
2966 elf_hash_table(info
)->dynobj
= dynobj
= abfd
;
2969 rel_sec_name
= NULL
;
2970 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2971 sym_hashes
= alpha_elf_sym_hashes(abfd
);
2972 got_created
= FALSE
;
2974 relend
= relocs
+ sec
->reloc_count
;
2975 for (rel
= relocs
; rel
< relend
; ++rel
)
2983 unsigned long r_symndx
, r_type
;
2984 struct alpha_elf_link_hash_entry
*h
;
2985 unsigned int gotent_flags
;
2986 bfd_boolean maybe_dynamic
;
2990 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2991 if (r_symndx
< symtab_hdr
->sh_info
)
2995 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2997 while (h
->root
.root
.type
== bfd_link_hash_indirect
2998 || h
->root
.root
.type
== bfd_link_hash_warning
)
2999 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3001 h
->root
.ref_regular
= 1;
3004 /* We can only get preliminary data on whether a symbol is
3005 locally or externally defined, as not all of the input files
3006 have yet been processed. Do something with what we know, as
3007 this may help reduce memory usage and processing time later. */
3008 maybe_dynamic
= FALSE
;
3009 if (h
&& ((info
->shared
3010 && (!info
->symbolic
|| info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
3011 || !h
->root
.def_regular
3012 || h
->root
.root
.type
== bfd_link_hash_defweak
))
3013 maybe_dynamic
= TRUE
;
3017 r_type
= ELF64_R_TYPE (rel
->r_info
);
3018 addend
= rel
->r_addend
;
3022 case R_ALPHA_LITERAL
:
3023 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3025 /* Remember how this literal is used from its LITUSEs.
3026 This will be important when it comes to decide if we can
3027 create a .plt entry for a function symbol. */
3028 while (++rel
< relend
&& ELF64_R_TYPE (rel
->r_info
) == R_ALPHA_LITUSE
)
3029 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 5)
3030 gotent_flags
|= 1 << rel
->r_addend
;
3033 /* No LITUSEs -- presumably the address is used somehow. */
3034 if (gotent_flags
== 0)
3035 gotent_flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
3038 case R_ALPHA_GPDISP
:
3039 case R_ALPHA_GPREL16
:
3040 case R_ALPHA_GPREL32
:
3041 case R_ALPHA_GPRELHIGH
:
3042 case R_ALPHA_GPRELLOW
:
3047 case R_ALPHA_REFLONG
:
3048 case R_ALPHA_REFQUAD
:
3049 if ((info
->shared
&& (sec
->flags
& SEC_ALLOC
)) || maybe_dynamic
)
3053 case R_ALPHA_TLSLDM
:
3054 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3055 reloc to the 0 symbol so that they all match. */
3058 maybe_dynamic
= FALSE
;
3062 case R_ALPHA_GOTDTPREL
:
3063 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3066 case R_ALPHA_GOTTPREL
:
3067 need
= NEED_GOT
| NEED_GOT_ENTRY
;
3068 gotent_flags
= ALPHA_ELF_LINK_HASH_TLS_IE
;
3070 info
->flags
|= DF_STATIC_TLS
;
3073 case R_ALPHA_TPREL64
:
3074 if (info
->shared
|| maybe_dynamic
)
3077 info
->flags
|= DF_STATIC_TLS
;
3081 if (need
& NEED_GOT
)
3085 if (!elf64_alpha_create_got_section (abfd
, info
))
3088 /* Make sure the object's gotobj is set to itself so
3089 that we default to every object with its own .got.
3090 We'll merge .gots later once we've collected each
3092 alpha_elf_tdata(abfd
)->gotobj
= abfd
;
3098 if (need
& NEED_GOT_ENTRY
)
3100 struct alpha_elf_got_entry
*gotent
;
3102 gotent
= get_got_entry (abfd
, h
, r_type
, r_symndx
, addend
);
3108 gotent
->flags
|= gotent_flags
;
3111 gotent_flags
|= h
->flags
;
3112 h
->flags
= gotent_flags
;
3114 /* Make a guess as to whether a .plt entry is needed. */
3115 if ((gotent_flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
3116 && !(gotent_flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
))
3117 h
->root
.needs_plt
= 1;
3119 h
->root
.needs_plt
= 0;
3124 if (need
& NEED_DYNREL
)
3126 if (rel_sec_name
== NULL
)
3128 rel_sec_name
= (bfd_elf_string_from_elf_section
3129 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
3130 elf_section_data(sec
)->rel_hdr
.sh_name
));
3131 if (rel_sec_name
== NULL
)
3134 BFD_ASSERT (strncmp (rel_sec_name
, ".rela", 5) == 0
3135 && strcmp (bfd_get_section_name (abfd
, sec
),
3136 rel_sec_name
+5) == 0);
3139 /* We need to create the section here now whether we eventually
3140 use it or not so that it gets mapped to an output section by
3141 the linker. If not used, we'll kill it in
3142 size_dynamic_sections. */
3145 sreloc
= bfd_get_section_by_name (dynobj
, rel_sec_name
);
3150 sreloc
= bfd_make_section (dynobj
, rel_sec_name
);
3151 flags
= (SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3152 | SEC_LINKER_CREATED
| SEC_READONLY
);
3153 if (sec
->flags
& SEC_ALLOC
)
3154 flags
|= SEC_ALLOC
| SEC_LOAD
;
3156 || !bfd_set_section_flags (dynobj
, sreloc
, flags
)
3157 || !bfd_set_section_alignment (dynobj
, sreloc
, 3))
3164 /* Since we havn't seen all of the input symbols yet, we
3165 don't know whether we'll actually need a dynamic relocation
3166 entry for this reloc. So make a record of it. Once we
3167 find out if this thing needs dynamic relocation we'll
3168 expand the relocation sections by the appropriate amount. */
3170 struct alpha_elf_reloc_entry
*rent
;
3172 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
3173 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
3178 amt
= sizeof (struct alpha_elf_reloc_entry
);
3179 rent
= (struct alpha_elf_reloc_entry
*) bfd_alloc (abfd
, amt
);
3183 rent
->srel
= sreloc
;
3184 rent
->rtype
= r_type
;
3186 rent
->reltext
= ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
3187 == (SEC_READONLY
| SEC_ALLOC
));
3189 rent
->next
= h
->reloc_entries
;
3190 h
->reloc_entries
= rent
;
3195 else if (info
->shared
)
3197 /* If this is a shared library, and the section is to be
3198 loaded into memory, we need a RELATIVE reloc. */
3199 sreloc
->size
+= sizeof (Elf64_External_Rela
);
3200 if ((sec
->flags
& (SEC_READONLY
| SEC_ALLOC
))
3201 == (SEC_READONLY
| SEC_ALLOC
))
3202 info
->flags
|= DF_TEXTREL
;
3210 /* Adjust a symbol defined by a dynamic object and referenced by a
3211 regular object. The current definition is in some section of the
3212 dynamic object, but we're not including those sections. We have to
3213 change the definition to something the rest of the link can
3217 elf64_alpha_adjust_dynamic_symbol (info
, h
)
3218 struct bfd_link_info
*info
;
3219 struct elf_link_hash_entry
*h
;
3223 struct alpha_elf_link_hash_entry
*ah
;
3225 dynobj
= elf_hash_table(info
)->dynobj
;
3226 ah
= (struct alpha_elf_link_hash_entry
*)h
;
3228 /* Now that we've seen all of the input symbols, finalize our decision
3229 about whether this symbol should get a .plt entry. */
3231 if (alpha_elf_dynamic_symbol_p (h
, info
)
3232 && ((h
->type
== STT_FUNC
3233 && !(ah
->flags
& ALPHA_ELF_LINK_HASH_LU_ADDR
))
3234 || (h
->type
== STT_NOTYPE
3235 && (ah
->flags
& ALPHA_ELF_LINK_HASH_LU_FUNC
)
3236 && !(ah
->flags
& ~ALPHA_ELF_LINK_HASH_LU_FUNC
)))
3237 /* Don't prevent otherwise valid programs from linking by attempting
3238 to create a new .got entry somewhere. A Correct Solution would be
3239 to add a new .got section to a new object file and let it be merged
3240 somewhere later. But for now don't bother. */
3245 s
= bfd_get_section_by_name(dynobj
, ".plt");
3246 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
3249 /* The first bit of the .plt is reserved. */
3251 s
->size
= PLT_HEADER_SIZE
;
3253 h
->plt
.offset
= s
->size
;
3254 s
->size
+= PLT_ENTRY_SIZE
;
3256 /* If this symbol is not defined in a regular file, and we are not
3257 generating a shared library, then set the symbol to the location
3258 in the .plt. This is required to make function pointers compare
3259 equal between the normal executable and the shared library. */
3261 && h
->root
.type
!= bfd_link_hash_defweak
)
3263 ah
->plt_old_section
= h
->root
.u
.def
.section
;
3264 ah
->plt_old_value
= h
->root
.u
.def
.value
;
3265 ah
->flags
|= ALPHA_ELF_LINK_HASH_PLT_LOC
;
3266 h
->root
.u
.def
.section
= s
;
3267 h
->root
.u
.def
.value
= h
->plt
.offset
;
3270 /* We also need a JMP_SLOT entry in the .rela.plt section. */
3271 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3272 BFD_ASSERT (s
!= NULL
);
3273 s
->size
+= sizeof (Elf64_External_Rela
);
3280 /* If this is a weak symbol, and there is a real definition, the
3281 processor independent code will have arranged for us to see the
3282 real definition first, and we can just use the same value. */
3283 if (h
->u
.weakdef
!= NULL
)
3285 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3286 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3287 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3288 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3292 /* This is a reference to a symbol defined by a dynamic object which
3293 is not a function. The Alpha, since it uses .got entries for all
3294 symbols even in regular objects, does not need the hackery of a
3295 .dynbss section and COPY dynamic relocations. */
3300 /* Symbol versioning can create new symbols, and make our old symbols
3301 indirect to the new ones. Consolidate the got and reloc information
3302 in these situations. */
3305 elf64_alpha_merge_ind_symbols (hi
, dummy
)
3306 struct alpha_elf_link_hash_entry
*hi
;
3307 PTR dummy ATTRIBUTE_UNUSED
;
3309 struct alpha_elf_link_hash_entry
*hs
;
3311 if (hi
->root
.root
.type
!= bfd_link_hash_indirect
)
3315 hs
= (struct alpha_elf_link_hash_entry
*)hs
->root
.root
.u
.i
.link
;
3316 } while (hs
->root
.root
.type
== bfd_link_hash_indirect
);
3318 /* Merge the flags. Whee. */
3320 hs
->flags
|= hi
->flags
;
3322 /* Merge the .got entries. Cannibalize the old symbol's list in
3323 doing so, since we don't need it anymore. */
3325 if (hs
->got_entries
== NULL
)
3326 hs
->got_entries
= hi
->got_entries
;
3329 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
3331 gsh
= hs
->got_entries
;
3332 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
3335 for (gs
= gsh
; gs
; gs
= gs
->next
)
3336 if (gi
->gotobj
== gs
->gotobj
3337 && gi
->reloc_type
== gs
->reloc_type
3338 && gi
->addend
== gs
->addend
)
3340 gi
->use_count
+= gs
->use_count
;
3343 gi
->next
= hs
->got_entries
;
3344 hs
->got_entries
= gi
;
3348 hi
->got_entries
= NULL
;
3350 /* And similar for the reloc entries. */
3352 if (hs
->reloc_entries
== NULL
)
3353 hs
->reloc_entries
= hi
->reloc_entries
;
3356 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
3358 rsh
= hs
->reloc_entries
;
3359 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
3362 for (rs
= rsh
; rs
; rs
= rs
->next
)
3363 if (ri
->rtype
== rs
->rtype
&& ri
->srel
== rs
->srel
)
3365 rs
->count
+= ri
->count
;
3368 ri
->next
= hs
->reloc_entries
;
3369 hs
->reloc_entries
= ri
;
3373 hi
->reloc_entries
= NULL
;
3378 /* Is it possible to merge two object file's .got tables? */
3381 elf64_alpha_can_merge_gots (a
, b
)
3384 int total
= alpha_elf_tdata (a
)->total_got_size
;
3387 /* Trivial quick fallout test. */
3388 if (total
+ alpha_elf_tdata (b
)->total_got_size
<= MAX_GOT_SIZE
)
3391 /* By their nature, local .got entries cannot be merged. */
3392 if ((total
+= alpha_elf_tdata (b
)->local_got_size
) > MAX_GOT_SIZE
)
3395 /* Failing the common trivial comparison, we must effectively
3396 perform the merge. Not actually performing the merge means that
3397 we don't have to store undo information in case we fail. */
3398 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3400 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
3401 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3404 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3405 for (i
= 0; i
< n
; ++i
)
3407 struct alpha_elf_got_entry
*ae
, *be
;
3408 struct alpha_elf_link_hash_entry
*h
;
3411 while (h
->root
.root
.type
== bfd_link_hash_indirect
3412 || h
->root
.root
.type
== bfd_link_hash_warning
)
3413 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3415 for (be
= h
->got_entries
; be
; be
= be
->next
)
3417 if (be
->use_count
== 0)
3419 if (be
->gotobj
!= b
)
3422 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
3424 && ae
->reloc_type
== be
->reloc_type
3425 && ae
->addend
== be
->addend
)
3428 total
+= alpha_got_entry_size (be
->reloc_type
);
3429 if (total
> MAX_GOT_SIZE
)
3439 /* Actually merge two .got tables. */
3442 elf64_alpha_merge_gots (a
, b
)
3445 int total
= alpha_elf_tdata (a
)->total_got_size
;
3448 /* Remember local expansion. */
3450 int e
= alpha_elf_tdata (b
)->local_got_size
;
3452 alpha_elf_tdata (a
)->local_got_size
+= e
;
3455 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
3457 struct alpha_elf_got_entry
**local_got_entries
;
3458 struct alpha_elf_link_hash_entry
**hashes
;
3459 Elf_Internal_Shdr
*symtab_hdr
;
3462 /* Let the local .got entries know they are part of a new subsegment. */
3463 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
3464 if (local_got_entries
)
3466 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
3467 for (i
= 0; i
< n
; ++i
)
3469 struct alpha_elf_got_entry
*ent
;
3470 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
3475 /* Merge the global .got entries. */
3476 hashes
= alpha_elf_sym_hashes (bsub
);
3477 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
3479 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
3480 for (i
= 0; i
< n
; ++i
)
3482 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
3483 struct alpha_elf_link_hash_entry
*h
;
3486 while (h
->root
.root
.type
== bfd_link_hash_indirect
3487 || h
->root
.root
.type
== bfd_link_hash_warning
)
3488 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3490 start
= &h
->got_entries
;
3491 for (pbe
= start
, be
= *start
; be
; pbe
= &be
->next
, be
= be
->next
)
3493 if (be
->use_count
== 0)
3498 if (be
->gotobj
!= b
)
3501 for (ae
= *start
; ae
; ae
= ae
->next
)
3503 && ae
->reloc_type
== be
->reloc_type
3504 && ae
->addend
== be
->addend
)
3506 ae
->flags
|= be
->flags
;
3507 ae
->use_count
+= be
->use_count
;
3512 total
+= alpha_got_entry_size (be
->reloc_type
);
3518 alpha_elf_tdata (bsub
)->gotobj
= a
;
3520 alpha_elf_tdata (a
)->total_got_size
= total
;
3522 /* Merge the two in_got chains. */
3527 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
3530 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
3534 /* Calculate the offsets for the got entries. */
3537 elf64_alpha_calc_got_offsets_for_symbol (h
, arg
)
3538 struct alpha_elf_link_hash_entry
*h
;
3539 PTR arg ATTRIBUTE_UNUSED
;
3541 bfd_boolean result
= TRUE
;
3542 struct alpha_elf_got_entry
*gotent
;
3544 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3545 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3547 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3548 if (gotent
->use_count
> 0)
3550 struct alpha_elf_obj_tdata
*td
;
3551 bfd_size_type
*plge
;
3553 td
= alpha_elf_tdata (gotent
->gotobj
);
3556 _bfd_error_handler (_("Symbol %s has no GOT subsection for offset 0x%x"),
3557 h
->root
.root
.root
.string
, gotent
->got_offset
);
3561 plge
= &td
->got
->size
;
3562 gotent
->got_offset
= *plge
;
3563 *plge
+= alpha_got_entry_size (gotent
->reloc_type
);
3570 elf64_alpha_calc_got_offsets (info
)
3571 struct bfd_link_info
*info
;
3573 bfd
*i
, *got_list
= alpha_elf_hash_table(info
)->got_list
;
3575 /* First, zero out the .got sizes, as we may be recalculating the
3576 .got after optimizing it. */
3577 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3578 alpha_elf_tdata(i
)->got
->size
= 0;
3580 /* Next, fill in the offsets for all the global entries. */
3581 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3582 elf64_alpha_calc_got_offsets_for_symbol
,
3585 /* Finally, fill in the offsets for the local entries. */
3586 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3588 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->size
;
3591 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3593 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3596 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3597 if (!local_got_entries
)
3600 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3601 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
3602 if (gotent
->use_count
> 0)
3604 gotent
->got_offset
= got_offset
;
3605 got_offset
+= alpha_got_entry_size (gotent
->reloc_type
);
3609 alpha_elf_tdata(i
)->got
->size
= got_offset
;
3613 /* Constructs the gots. */
3616 elf64_alpha_size_got_sections (info
)
3617 struct bfd_link_info
*info
;
3619 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
3620 int something_changed
= 0;
3622 got_list
= alpha_elf_hash_table (info
)->got_list
;
3624 /* On the first time through, pretend we have an existing got list
3625 consisting of all of the input files. */
3626 if (got_list
== NULL
)
3628 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
3630 bfd
*this_got
= alpha_elf_tdata (i
)->gotobj
;
3631 if (this_got
== NULL
)
3634 /* We are assuming no merging has yet occurred. */
3635 BFD_ASSERT (this_got
== i
);
3637 if (alpha_elf_tdata (this_got
)->total_got_size
> MAX_GOT_SIZE
)
3639 /* Yikes! A single object file has too many entries. */
3640 (*_bfd_error_handler
)
3641 (_("%B: .got subsegment exceeds 64K (size %d)"),
3642 i
, alpha_elf_tdata (this_got
)->total_got_size
);
3646 if (got_list
== NULL
)
3647 got_list
= this_got
;
3649 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
3650 cur_got_obj
= this_got
;
3653 /* Strange degenerate case of no got references. */
3654 if (got_list
== NULL
)
3657 alpha_elf_hash_table (info
)->got_list
= got_list
;
3659 /* Force got offsets to be recalculated. */
3660 something_changed
= 1;
3663 cur_got_obj
= got_list
;
3664 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
3667 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
3669 elf64_alpha_merge_gots (cur_got_obj
, i
);
3670 i
= alpha_elf_tdata(i
)->got_link_next
;
3671 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
3672 something_changed
= 1;
3677 i
= alpha_elf_tdata(i
)->got_link_next
;
3681 /* Once the gots have been merged, fill in the got offsets for
3682 everything therein. */
3683 if (1 || something_changed
)
3684 elf64_alpha_calc_got_offsets (info
);
3689 /* Called from relax_section to rebuild the PLT in light of
3690 potential changes in the function's status. */
3693 elf64_alpha_size_plt_section (info
)
3694 struct bfd_link_info
*info
;
3696 asection
*splt
, *spltrel
;
3697 unsigned long entries
;
3700 dynobj
= elf_hash_table(info
)->dynobj
;
3701 splt
= bfd_get_section_by_name(dynobj
, ".plt");
3707 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3708 elf64_alpha_size_plt_section_1
, splt
);
3710 /* Every plt entry requires a JMP_SLOT relocation. */
3711 spltrel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3713 entries
= (splt
->size
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3716 spltrel
->size
= entries
* sizeof (Elf64_External_Rela
);
3722 elf64_alpha_size_plt_section_1 (h
, data
)
3723 struct alpha_elf_link_hash_entry
*h
;
3726 asection
*splt
= (asection
*) data
;
3727 struct alpha_elf_got_entry
*gotent
;
3729 /* If we didn't need an entry before, we still don't. */
3730 if (!h
->root
.needs_plt
)
3733 /* There must still be a LITERAL got entry for the function. */
3734 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3735 if (gotent
->reloc_type
== R_ALPHA_LITERAL
3736 && gotent
->use_count
> 0)
3739 /* If there is, reset the PLT offset. If not, there's no longer
3740 a need for the PLT entry. */
3743 if (splt
->size
== 0)
3744 splt
->size
= PLT_HEADER_SIZE
;
3745 h
->root
.plt
.offset
= splt
->size
;
3746 splt
->size
+= PLT_ENTRY_SIZE
;
3750 h
->root
.needs_plt
= 0;
3751 h
->root
.plt
.offset
= -1;
3753 /* Undo the definition frobbing begun in adjust_dynamic_symbol. */
3754 if (h
->flags
& ALPHA_ELF_LINK_HASH_PLT_LOC
)
3756 h
->root
.root
.u
.def
.section
= h
->plt_old_section
;
3757 h
->root
.root
.u
.def
.value
= h
->plt_old_value
;
3758 h
->flags
&= ~ALPHA_ELF_LINK_HASH_PLT_LOC
;
3766 elf64_alpha_always_size_sections (output_bfd
, info
)
3767 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3768 struct bfd_link_info
*info
;
3772 if (info
->relocatable
)
3775 /* First, take care of the indirect symbols created by versioning. */
3776 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3777 elf64_alpha_merge_ind_symbols
,
3780 if (!elf64_alpha_size_got_sections (info
))
3783 /* Allocate space for all of the .got subsections. */
3784 i
= alpha_elf_hash_table (info
)->got_list
;
3785 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3787 asection
*s
= alpha_elf_tdata(i
)->got
;
3790 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->size
);
3791 if (s
->contents
== NULL
)
3799 /* The number of dynamic relocations required by a static relocation. */
3802 alpha_dynamic_entries_for_reloc (r_type
, dynamic
, shared
)
3803 int r_type
, dynamic
, shared
;
3807 /* May appear in GOT entries. */
3809 return (dynamic
? 2 : shared
? 1 : 0);
3810 case R_ALPHA_TLSLDM
:
3812 case R_ALPHA_LITERAL
:
3813 case R_ALPHA_GOTTPREL
:
3814 return dynamic
|| shared
;
3815 case R_ALPHA_GOTDTPREL
:
3818 /* May appear in data sections. */
3819 case R_ALPHA_REFLONG
:
3820 case R_ALPHA_REFQUAD
:
3821 case R_ALPHA_TPREL64
:
3822 return dynamic
|| shared
;
3824 /* Everything else is illegal. We'll issue an error during
3825 relocate_section. */
3831 /* Work out the sizes of the dynamic relocation entries. */
3834 elf64_alpha_calc_dynrel_sizes (h
, info
)
3835 struct alpha_elf_link_hash_entry
*h
;
3836 struct bfd_link_info
*info
;
3838 bfd_boolean dynamic
;
3839 struct alpha_elf_reloc_entry
*relent
;
3840 unsigned long entries
;
3842 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3843 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3845 /* If the symbol was defined as a common symbol in a regular object
3846 file, and there was no definition in any dynamic object, then the
3847 linker will have allocated space for the symbol in a common
3848 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3849 set. This is done for dynamic symbols in
3850 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3851 symbols, somehow. */
3852 if (!h
->root
.def_regular
3853 && h
->root
.ref_regular
3854 && !h
->root
.def_dynamic
3855 && (h
->root
.root
.type
== bfd_link_hash_defined
3856 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3857 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3858 h
->root
.def_regular
= 1;
3860 /* If the symbol is dynamic, we'll need all the relocations in their
3861 natural form. If this is a shared object, and it has been forced
3862 local, we'll need the same number of RELATIVE relocations. */
3864 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3866 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
3868 entries
= alpha_dynamic_entries_for_reloc (relent
->rtype
, dynamic
,
3872 relent
->srel
->size
+=
3873 entries
* sizeof (Elf64_External_Rela
) * relent
->count
;
3874 if (relent
->reltext
)
3875 info
->flags
|= DT_TEXTREL
;
3882 /* Set the sizes of the dynamic relocation sections. */
3885 elf64_alpha_size_rela_got_section (info
)
3886 struct bfd_link_info
*info
;
3888 unsigned long entries
;
3892 /* Shared libraries often require RELATIVE relocs, and some relocs
3893 require attention for the main application as well. */
3896 for (i
= alpha_elf_hash_table(info
)->got_list
;
3897 i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3901 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
3903 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
3906 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
3907 if (!local_got_entries
)
3910 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
3911 for (gotent
= local_got_entries
[k
];
3912 gotent
; gotent
= gotent
->next
)
3913 if (gotent
->use_count
> 0)
3914 entries
+= (alpha_dynamic_entries_for_reloc
3915 (gotent
->reloc_type
, 0, info
->shared
));
3919 dynobj
= elf_hash_table(info
)->dynobj
;
3920 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3923 BFD_ASSERT (entries
== 0);
3926 srel
->size
= sizeof (Elf64_External_Rela
) * entries
;
3928 /* Now do the non-local symbols. */
3929 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3930 elf64_alpha_size_rela_got_1
, info
);
3935 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
3939 elf64_alpha_size_rela_got_1 (h
, info
)
3940 struct alpha_elf_link_hash_entry
*h
;
3941 struct bfd_link_info
*info
;
3943 bfd_boolean dynamic
;
3944 struct alpha_elf_got_entry
*gotent
;
3945 unsigned long entries
;
3947 if (h
->root
.root
.type
== bfd_link_hash_warning
)
3948 h
= (struct alpha_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
3950 /* If the symbol is dynamic, we'll need all the relocations in their
3951 natural form. If this is a shared object, and it has been forced
3952 local, we'll need the same number of RELATIVE relocations. */
3954 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3957 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3958 if (gotent
->use_count
> 0)
3959 entries
+= alpha_dynamic_entries_for_reloc (gotent
->reloc_type
,
3960 dynamic
, info
->shared
);
3962 /* If we are using a .plt entry, subtract one, as the first
3963 reference uses a .rela.plt entry instead. */
3964 if (h
->root
.plt
.offset
!= MINUS_ONE
)
3969 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
3970 asection
*srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3971 BFD_ASSERT (srel
!= NULL
);
3972 srel
->size
+= sizeof (Elf64_External_Rela
) * entries
;
3978 /* Set the sizes of the dynamic sections. */
3981 elf64_alpha_size_dynamic_sections (output_bfd
, info
)
3982 bfd
*output_bfd ATTRIBUTE_UNUSED
;
3983 struct bfd_link_info
*info
;
3989 dynobj
= elf_hash_table(info
)->dynobj
;
3990 BFD_ASSERT(dynobj
!= NULL
);
3992 if (elf_hash_table (info
)->dynamic_sections_created
)
3994 /* Set the contents of the .interp section to the interpreter. */
3995 if (info
->executable
)
3997 s
= bfd_get_section_by_name (dynobj
, ".interp");
3998 BFD_ASSERT (s
!= NULL
);
3999 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4000 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
4003 /* Now that we've seen all of the input files, we can decide which
4004 symbols need dynamic relocation entries and which don't. We've
4005 collected information in check_relocs that we can now apply to
4006 size the dynamic relocation sections. */
4007 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
4008 elf64_alpha_calc_dynrel_sizes
, info
);
4010 elf64_alpha_size_rela_got_section (info
);
4012 /* else we're not dynamic and by definition we don't need such things. */
4014 /* The check_relocs and adjust_dynamic_symbol entry points have
4015 determined the sizes of the various dynamic sections. Allocate
4018 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
4023 if (!(s
->flags
& SEC_LINKER_CREATED
))
4026 /* It's OK to base decisions on the section name, because none
4027 of the dynobj section names depend upon the input files. */
4028 name
= bfd_get_section_name (dynobj
, s
);
4030 /* If we don't need this section, strip it from the output file.
4031 This is to handle .rela.bss and .rela.plt. We must create it
4032 in create_dynamic_sections, because it must be created before
4033 the linker maps input sections to output sections. The
4034 linker does that before adjust_dynamic_symbol is called, and
4035 it is that function which decides whether anything needs to
4036 go into these sections. */
4040 if (strncmp (name
, ".rela", 5) == 0)
4042 strip
= (s
->size
== 0);
4046 if (strcmp(name
, ".rela.plt") == 0)
4049 /* We use the reloc_count field as a counter if we need
4050 to copy relocs into the output file. */
4054 else if (strcmp (name
, ".plt") != 0)
4056 /* It's not one of our dynamic sections, so don't allocate space. */
4061 _bfd_strip_section_from_output (info
, s
);
4064 /* Allocate memory for the section contents. */
4065 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
4066 if (s
->contents
== NULL
&& s
->size
!= 0)
4071 if (elf_hash_table (info
)->dynamic_sections_created
)
4073 /* Add some entries to the .dynamic section. We fill in the
4074 values later, in elf64_alpha_finish_dynamic_sections, but we
4075 must add the entries now so that we get the correct size for
4076 the .dynamic section. The DT_DEBUG entry is filled in by the
4077 dynamic linker and used by the debugger. */
4078 #define add_dynamic_entry(TAG, VAL) \
4079 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4081 if (info
->executable
)
4083 if (!add_dynamic_entry (DT_DEBUG
, 0))
4089 if (!add_dynamic_entry (DT_PLTGOT
, 0)
4090 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
4091 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
4092 || !add_dynamic_entry (DT_JMPREL
, 0))
4096 if (!add_dynamic_entry (DT_RELA
, 0)
4097 || !add_dynamic_entry (DT_RELASZ
, 0)
4098 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
4101 if (info
->flags
& DF_TEXTREL
)
4103 if (!add_dynamic_entry (DT_TEXTREL
, 0))
4107 #undef add_dynamic_entry
4112 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4113 into the next available slot in SREL. */
4116 elf64_alpha_emit_dynrel (abfd
, info
, sec
, srel
, offset
, dynindx
, rtype
, addend
)
4118 struct bfd_link_info
*info
;
4119 asection
*sec
, *srel
;
4120 bfd_vma offset
, addend
;
4121 long dynindx
, rtype
;
4123 Elf_Internal_Rela outrel
;
4126 BFD_ASSERT (srel
!= NULL
);
4128 outrel
.r_info
= ELF64_R_INFO (dynindx
, rtype
);
4129 outrel
.r_addend
= addend
;
4131 offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
4132 if ((offset
| 1) != (bfd_vma
) -1)
4133 outrel
.r_offset
= sec
->output_section
->vma
+ sec
->output_offset
+ offset
;
4135 memset (&outrel
, 0, sizeof (outrel
));
4137 loc
= srel
->contents
;
4138 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
4139 bfd_elf64_swap_reloca_out (abfd
, &outrel
, loc
);
4140 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
<= srel
->size
);
4143 /* Relocate an Alpha ELF section for a relocatable link.
4145 We don't have to change anything unless the reloc is against a section
4146 symbol, in which case we have to adjust according to where the section
4147 symbol winds up in the output section. */
4150 elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
, input_section
,
4151 contents
, relocs
, local_syms
, local_sections
)
4152 bfd
*output_bfd ATTRIBUTE_UNUSED
;
4153 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4155 asection
*input_section
;
4156 bfd_byte
*contents ATTRIBUTE_UNUSED
;
4157 Elf_Internal_Rela
*relocs
;
4158 Elf_Internal_Sym
*local_syms
;
4159 asection
**local_sections
;
4161 unsigned long symtab_hdr_sh_info
;
4162 Elf_Internal_Rela
*rel
;
4163 Elf_Internal_Rela
*relend
;
4164 bfd_boolean ret_val
= TRUE
;
4166 symtab_hdr_sh_info
= elf_tdata (input_bfd
)->symtab_hdr
.sh_info
;
4168 relend
= relocs
+ input_section
->reloc_count
;
4169 for (rel
= relocs
; rel
< relend
; rel
++)
4171 unsigned long r_symndx
;
4172 Elf_Internal_Sym
*sym
;
4174 unsigned long r_type
;
4176 r_type
= ELF64_R_TYPE(rel
->r_info
);
4177 if (r_type
>= R_ALPHA_max
)
4179 (*_bfd_error_handler
)
4180 (_("%B: unknown relocation type %d"),
4181 input_bfd
, (int) r_type
);
4182 bfd_set_error (bfd_error_bad_value
);
4187 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4189 /* The symbol associated with GPDISP and LITUSE is
4190 immaterial. Only the addend is significant. */
4191 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
4194 if (r_symndx
< symtab_hdr_sh_info
)
4196 sym
= local_syms
+ r_symndx
;
4197 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
4199 sec
= local_sections
[r_symndx
];
4200 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
4208 /* Relocate an Alpha ELF section. */
4211 elf64_alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
4212 contents
, relocs
, local_syms
, local_sections
)
4214 struct bfd_link_info
*info
;
4216 asection
*input_section
;
4218 Elf_Internal_Rela
*relocs
;
4219 Elf_Internal_Sym
*local_syms
;
4220 asection
**local_sections
;
4222 Elf_Internal_Shdr
*symtab_hdr
;
4223 Elf_Internal_Rela
*rel
;
4224 Elf_Internal_Rela
*relend
;
4225 asection
*sgot
, *srel
, *srelgot
;
4226 bfd
*dynobj
, *gotobj
;
4227 bfd_vma gp
, tp_base
, dtp_base
;
4228 struct alpha_elf_got_entry
**local_got_entries
;
4229 bfd_boolean ret_val
;
4230 const char *section_name
;
4232 /* Handle relocatable links with a smaller loop. */
4233 if (info
->relocatable
)
4234 return elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
,
4235 input_section
, contents
, relocs
,
4236 local_syms
, local_sections
);
4238 /* This is a final link. */
4242 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4244 dynobj
= elf_hash_table (info
)->dynobj
;
4246 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
4250 section_name
= (bfd_elf_string_from_elf_section
4251 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
4252 elf_section_data(input_section
)->rel_hdr
.sh_name
));
4253 BFD_ASSERT(section_name
!= NULL
);
4254 srel
= bfd_get_section_by_name (dynobj
, section_name
);
4256 /* Find the gp value for this input bfd. */
4257 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
4260 sgot
= alpha_elf_tdata (gotobj
)->got
;
4261 gp
= _bfd_get_gp_value (gotobj
);
4264 gp
= (sgot
->output_section
->vma
4265 + sgot
->output_offset
4267 _bfd_set_gp_value (gotobj
, gp
);
4276 local_got_entries
= alpha_elf_tdata(input_bfd
)->local_got_entries
;
4278 if (elf_hash_table (info
)->tls_sec
!= NULL
)
4280 dtp_base
= alpha_get_dtprel_base (info
);
4281 tp_base
= alpha_get_tprel_base (info
);
4284 dtp_base
= tp_base
= 0;
4286 relend
= relocs
+ input_section
->reloc_count
;
4287 for (rel
= relocs
; rel
< relend
; rel
++)
4289 struct alpha_elf_link_hash_entry
*h
= NULL
;
4290 struct alpha_elf_got_entry
*gotent
;
4291 bfd_reloc_status_type r
;
4292 reloc_howto_type
*howto
;
4293 unsigned long r_symndx
;
4294 Elf_Internal_Sym
*sym
= NULL
;
4295 asection
*sec
= NULL
;
4298 bfd_boolean dynamic_symbol_p
;
4299 bfd_boolean undef_weak_ref
= FALSE
;
4300 unsigned long r_type
;
4302 r_type
= ELF64_R_TYPE(rel
->r_info
);
4303 if (r_type
>= R_ALPHA_max
)
4305 (*_bfd_error_handler
)
4306 (_("%B: unknown relocation type %d"),
4307 input_bfd
, (int) r_type
);
4308 bfd_set_error (bfd_error_bad_value
);
4313 howto
= elf64_alpha_howto_table
+ r_type
;
4314 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4316 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4317 reloc to the 0 symbol so that they all match. */
4318 if (r_type
== R_ALPHA_TLSLDM
)
4321 if (r_symndx
< symtab_hdr
->sh_info
)
4324 sym
= local_syms
+ r_symndx
;
4325 sec
= local_sections
[r_symndx
];
4327 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
4329 /* If this is a tp-relative relocation against sym 0,
4330 this is hackery from relax_section. Force the value to
4333 && (r_type
== R_ALPHA_TLSLDM
4334 || r_type
== R_ALPHA_GOTTPREL
4335 || r_type
== R_ALPHA_TPREL64
4336 || r_type
== R_ALPHA_TPRELHI
4337 || r_type
== R_ALPHA_TPRELLO
4338 || r_type
== R_ALPHA_TPREL16
))
4341 if (local_got_entries
)
4342 gotent
= local_got_entries
[r_symndx
];
4346 /* Need to adjust local GOT entries' addends for SEC_MERGE
4347 unless it has been done already. */
4348 if ((sec
->flags
& SEC_MERGE
)
4349 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
4350 && sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
4352 && !gotent
->reloc_xlated
)
4354 struct alpha_elf_got_entry
*ent
;
4356 for (ent
= gotent
; ent
; ent
= ent
->next
)
4358 ent
->reloc_xlated
= 1;
4359 if (ent
->use_count
== 0)
4363 _bfd_merged_section_offset (output_bfd
, &msec
,
4364 elf_section_data (sec
)->
4366 sym
->st_value
+ ent
->addend
);
4367 ent
->addend
-= sym
->st_value
;
4368 ent
->addend
+= msec
->output_section
->vma
4369 + msec
->output_offset
4370 - sec
->output_section
->vma
4371 - sec
->output_offset
;
4375 dynamic_symbol_p
= FALSE
;
4380 bfd_boolean unresolved_reloc
;
4381 struct elf_link_hash_entry
*hh
;
4382 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
4384 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4385 r_symndx
, symtab_hdr
, sym_hashes
,
4387 unresolved_reloc
, warned
);
4393 && ! unresolved_reloc
4394 && hh
->root
.type
== bfd_link_hash_undefweak
)
4395 undef_weak_ref
= TRUE
;
4397 h
= (struct alpha_elf_link_hash_entry
*) hh
;
4398 dynamic_symbol_p
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
4399 gotent
= h
->got_entries
;
4402 addend
= rel
->r_addend
;
4405 /* Search for the proper got entry. */
4406 for (; gotent
; gotent
= gotent
->next
)
4407 if (gotent
->gotobj
== gotobj
4408 && gotent
->reloc_type
== r_type
4409 && gotent
->addend
== addend
)
4414 case R_ALPHA_GPDISP
:
4416 bfd_byte
*p_ldah
, *p_lda
;
4418 BFD_ASSERT(gp
!= 0);
4420 value
= (input_section
->output_section
->vma
4421 + input_section
->output_offset
4424 p_ldah
= contents
+ rel
->r_offset
;
4425 p_lda
= p_ldah
+ rel
->r_addend
;
4427 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- value
,
4432 case R_ALPHA_LITERAL
:
4433 BFD_ASSERT(sgot
!= NULL
);
4434 BFD_ASSERT(gp
!= 0);
4435 BFD_ASSERT(gotent
!= NULL
);
4436 BFD_ASSERT(gotent
->use_count
>= 1);
4438 if (!gotent
->reloc_done
)
4440 gotent
->reloc_done
= 1;
4442 bfd_put_64 (output_bfd
, value
,
4443 sgot
->contents
+ gotent
->got_offset
);
4445 /* If the symbol has been forced local, output a
4446 RELATIVE reloc, otherwise it will be handled in
4447 finish_dynamic_symbol. */
4448 if (info
->shared
&& !dynamic_symbol_p
)
4449 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4450 gotent
->got_offset
, 0,
4451 R_ALPHA_RELATIVE
, value
);
4454 value
= (sgot
->output_section
->vma
4455 + sgot
->output_offset
4456 + gotent
->got_offset
);
4460 case R_ALPHA_GPREL32
:
4461 /* If the target section was a removed linkonce section,
4462 r_symndx will be zero. In this case, assume that the
4463 switch will not be used, so don't fill it in. If we
4464 do nothing here, we'll get relocation truncated messages,
4465 due to the placement of the application above 4GB. */
4473 case R_ALPHA_GPREL16
:
4474 case R_ALPHA_GPRELLOW
:
4475 if (dynamic_symbol_p
)
4477 (*_bfd_error_handler
)
4478 (_("%B: gp-relative relocation against dynamic symbol %s"),
4479 input_bfd
, h
->root
.root
.root
.string
);
4482 BFD_ASSERT(gp
!= 0);
4486 case R_ALPHA_GPRELHIGH
:
4487 if (dynamic_symbol_p
)
4489 (*_bfd_error_handler
)
4490 (_("%B: gp-relative relocation against dynamic symbol %s"),
4491 input_bfd
, h
->root
.root
.root
.string
);
4494 BFD_ASSERT(gp
!= 0);
4496 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4500 /* A call to a dynamic symbol is definitely out of range of
4501 the 16-bit displacement. Don't bother writing anything. */
4502 if (dynamic_symbol_p
)
4507 /* The regular PC-relative stuff measures from the start of
4508 the instruction rather than the end. */
4512 case R_ALPHA_BRADDR
:
4513 if (dynamic_symbol_p
)
4515 (*_bfd_error_handler
)
4516 (_("%B: pc-relative relocation against dynamic symbol %s"),
4517 input_bfd
, h
->root
.root
.root
.string
);
4520 /* The regular PC-relative stuff measures from the start of
4521 the instruction rather than the end. */
4530 /* The regular PC-relative stuff measures from the start of
4531 the instruction rather than the end. */
4534 /* The source and destination gp must be the same. Note that
4535 the source will always have an assigned gp, since we forced
4536 one in check_relocs, but that the destination may not, as
4537 it might not have had any relocations at all. Also take
4538 care not to crash if H is an undefined symbol. */
4539 if (h
!= NULL
&& sec
!= NULL
4540 && alpha_elf_tdata (sec
->owner
)->gotobj
4541 && gotobj
!= alpha_elf_tdata (sec
->owner
)->gotobj
)
4543 (*_bfd_error_handler
)
4544 (_("%B: change in gp: BRSGP %s"),
4545 input_bfd
, h
->root
.root
.root
.string
);
4549 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4551 other
= h
->root
.other
;
4553 other
= sym
->st_other
;
4554 switch (other
& STO_ALPHA_STD_GPLOAD
)
4556 case STO_ALPHA_NOPV
:
4558 case STO_ALPHA_STD_GPLOAD
:
4563 name
= h
->root
.root
.root
.string
;
4566 name
= (bfd_elf_string_from_elf_section
4567 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4569 name
= _("<unknown>");
4570 else if (name
[0] == 0)
4571 name
= bfd_section_name (input_bfd
, sec
);
4573 (*_bfd_error_handler
)
4574 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4583 case R_ALPHA_REFLONG
:
4584 case R_ALPHA_REFQUAD
:
4585 case R_ALPHA_DTPREL64
:
4586 case R_ALPHA_TPREL64
:
4588 long dynindx
, dyntype
= r_type
;
4591 /* Careful here to remember RELATIVE relocations for global
4592 variables for symbolic shared objects. */
4594 if (dynamic_symbol_p
)
4596 BFD_ASSERT(h
->root
.dynindx
!= -1);
4597 dynindx
= h
->root
.dynindx
;
4599 addend
= 0, value
= 0;
4601 else if (r_type
== R_ALPHA_DTPREL64
)
4603 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4607 else if (r_type
== R_ALPHA_TPREL64
)
4609 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4616 dynaddend
= value
- dtp_base
;
4618 else if (info
->shared
4620 && (input_section
->flags
& SEC_ALLOC
))
4622 if (r_type
== R_ALPHA_REFLONG
)
4624 (*_bfd_error_handler
)
4625 (_("%B: unhandled dynamic relocation against %s"),
4627 h
->root
.root
.root
.string
);
4631 dyntype
= R_ALPHA_RELATIVE
;
4637 elf64_alpha_emit_dynrel (output_bfd
, info
, input_section
,
4638 srel
, rel
->r_offset
, dynindx
,
4639 dyntype
, dynaddend
);
4643 case R_ALPHA_SREL16
:
4644 case R_ALPHA_SREL32
:
4645 case R_ALPHA_SREL64
:
4646 if (dynamic_symbol_p
)
4648 (*_bfd_error_handler
)
4649 (_("%B: pc-relative relocation against dynamic symbol %s"),
4650 input_bfd
, h
->root
.root
.root
.string
);
4654 /* ??? .eh_frame references to discarded sections will be smashed
4655 to relocations against SHN_UNDEF. The .eh_frame format allows
4656 NULL to be encoded as 0 in any format, so this works here. */
4658 howto
= (elf64_alpha_howto_table
4659 + (r_type
- R_ALPHA_SREL32
+ R_ALPHA_REFLONG
));
4662 case R_ALPHA_TLSLDM
:
4663 /* Ignore the symbol for the relocation. The result is always
4664 the current module. */
4665 dynamic_symbol_p
= 0;
4669 if (!gotent
->reloc_done
)
4671 gotent
->reloc_done
= 1;
4673 /* Note that the module index for the main program is 1. */
4674 bfd_put_64 (output_bfd
, !info
->shared
&& !dynamic_symbol_p
,
4675 sgot
->contents
+ gotent
->got_offset
);
4677 /* If the symbol has been forced local, output a
4678 DTPMOD64 reloc, otherwise it will be handled in
4679 finish_dynamic_symbol. */
4680 if (info
->shared
&& !dynamic_symbol_p
)
4681 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4682 gotent
->got_offset
, 0,
4683 R_ALPHA_DTPMOD64
, 0);
4685 if (dynamic_symbol_p
|| r_type
== R_ALPHA_TLSLDM
)
4689 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4692 bfd_put_64 (output_bfd
, value
,
4693 sgot
->contents
+ gotent
->got_offset
+ 8);
4696 value
= (sgot
->output_section
->vma
4697 + sgot
->output_offset
4698 + gotent
->got_offset
);
4702 case R_ALPHA_DTPRELHI
:
4703 case R_ALPHA_DTPRELLO
:
4704 case R_ALPHA_DTPREL16
:
4705 if (dynamic_symbol_p
)
4707 (*_bfd_error_handler
)
4708 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4709 input_bfd
, h
->root
.root
.root
.string
);
4712 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4714 if (r_type
== R_ALPHA_DTPRELHI
)
4715 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4718 case R_ALPHA_TPRELHI
:
4719 case R_ALPHA_TPRELLO
:
4720 case R_ALPHA_TPREL16
:
4723 (*_bfd_error_handler
)
4724 (_("%B: TLS local exec code cannot be linked into shared objects"),
4728 else if (dynamic_symbol_p
)
4730 (*_bfd_error_handler
)
4731 (_("%B: tp-relative relocation against dynamic symbol %s"),
4732 input_bfd
, h
->root
.root
.root
.string
);
4735 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4737 if (r_type
== R_ALPHA_TPRELHI
)
4738 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4741 case R_ALPHA_GOTDTPREL
:
4742 case R_ALPHA_GOTTPREL
:
4743 BFD_ASSERT(sgot
!= NULL
);
4744 BFD_ASSERT(gp
!= 0);
4745 BFD_ASSERT(gotent
!= NULL
);
4746 BFD_ASSERT(gotent
->use_count
>= 1);
4748 if (!gotent
->reloc_done
)
4750 gotent
->reloc_done
= 1;
4752 if (dynamic_symbol_p
)
4756 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4757 if (r_type
== R_ALPHA_GOTDTPREL
)
4759 else if (!info
->shared
)
4763 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4764 gotent
->got_offset
, 0,
4770 bfd_put_64 (output_bfd
, value
,
4771 sgot
->contents
+ gotent
->got_offset
);
4774 value
= (sgot
->output_section
->vma
4775 + sgot
->output_offset
4776 + gotent
->got_offset
);
4782 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4783 contents
, rel
->r_offset
, value
, 0);
4792 case bfd_reloc_overflow
:
4796 /* Don't warn if the overflow is due to pc relative reloc
4797 against discarded section. Section optimization code should
4800 if (r_symndx
< symtab_hdr
->sh_info
4801 && sec
!= NULL
&& howto
->pc_relative
4802 && elf_discarded_section (sec
))
4809 name
= (bfd_elf_string_from_elf_section
4810 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4814 name
= bfd_section_name (input_bfd
, sec
);
4816 if (! ((*info
->callbacks
->reloc_overflow
)
4817 (info
, (h
? &h
->root
.root
: NULL
), name
, howto
->name
,
4818 (bfd_vma
) 0, input_bfd
, input_section
,
4825 case bfd_reloc_outofrange
:
4833 /* Finish up dynamic symbol handling. We set the contents of various
4834 dynamic sections here. */
4837 elf64_alpha_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4839 struct bfd_link_info
*info
;
4840 struct elf_link_hash_entry
*h
;
4841 Elf_Internal_Sym
*sym
;
4843 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
4845 if (h
->plt
.offset
!= MINUS_ONE
)
4847 /* Fill in the .plt entry for this symbol. */
4848 asection
*splt
, *sgot
, *srel
;
4849 Elf_Internal_Rela outrel
;
4851 bfd_vma got_addr
, plt_addr
;
4853 struct alpha_elf_got_entry
*gotent
;
4855 BFD_ASSERT (h
->dynindx
!= -1);
4857 /* The first .got entry will be updated by the .plt with the
4858 address of the target function. */
4859 gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4860 BFD_ASSERT (gotent
&& gotent
->addend
== 0);
4862 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4863 BFD_ASSERT (splt
!= NULL
);
4864 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4865 BFD_ASSERT (srel
!= NULL
);
4866 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4867 BFD_ASSERT (sgot
!= NULL
);
4869 got_addr
= (sgot
->output_section
->vma
4870 + sgot
->output_offset
4871 + gotent
->got_offset
);
4872 plt_addr
= (splt
->output_section
->vma
4873 + splt
->output_offset
4876 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
4878 /* Fill in the entry in the procedure linkage table. */
4880 bfd_vma insn1
, insn2
, insn3
;
4882 insn1
= PLT_ENTRY_WORD1
| ((-(h
->plt
.offset
+ 4) >> 2) & 0x1fffff);
4883 insn2
= PLT_ENTRY_WORD2
;
4884 insn3
= PLT_ENTRY_WORD3
;
4886 bfd_put_32 (output_bfd
, insn1
, splt
->contents
+ h
->plt
.offset
);
4887 bfd_put_32 (output_bfd
, insn2
, splt
->contents
+ h
->plt
.offset
+ 4);
4888 bfd_put_32 (output_bfd
, insn3
, splt
->contents
+ h
->plt
.offset
+ 8);
4891 /* Fill in the entry in the .rela.plt section. */
4892 outrel
.r_offset
= got_addr
;
4893 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
4894 outrel
.r_addend
= 0;
4896 loc
= srel
->contents
+ plt_index
* sizeof (Elf64_External_Rela
);
4897 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
4899 if (!h
->def_regular
)
4901 /* Mark the symbol as undefined, rather than as defined in the
4902 .plt section. Leave the value alone. */
4903 sym
->st_shndx
= SHN_UNDEF
;
4906 /* Fill in the entries in the .got. */
4907 bfd_put_64 (output_bfd
, plt_addr
, sgot
->contents
+ gotent
->got_offset
);
4909 /* Subsequent .got entries will continue to bounce through the .plt. */
4912 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4913 BFD_ASSERT (! info
->shared
|| srel
!= NULL
);
4915 gotent
= gotent
->next
;
4918 sgot
= alpha_elf_tdata(gotent
->gotobj
)->got
;
4919 BFD_ASSERT(sgot
!= NULL
);
4920 BFD_ASSERT(gotent
->addend
== 0);
4922 bfd_put_64 (output_bfd
, plt_addr
,
4923 sgot
->contents
+ gotent
->got_offset
);
4926 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4927 gotent
->got_offset
, 0,
4928 R_ALPHA_RELATIVE
, plt_addr
);
4930 gotent
= gotent
->next
;
4932 while (gotent
!= NULL
);
4935 else if (alpha_elf_dynamic_symbol_p (h
, info
))
4937 /* Fill in the dynamic relocations for this symbol's .got entries. */
4939 struct alpha_elf_got_entry
*gotent
;
4941 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4942 BFD_ASSERT (srel
!= NULL
);
4944 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4946 gotent
= gotent
->next
)
4951 if (gotent
->use_count
== 0)
4954 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4956 r_type
= gotent
->reloc_type
;
4959 case R_ALPHA_LITERAL
:
4960 r_type
= R_ALPHA_GLOB_DAT
;
4963 r_type
= R_ALPHA_DTPMOD64
;
4965 case R_ALPHA_GOTDTPREL
:
4966 r_type
= R_ALPHA_DTPREL64
;
4968 case R_ALPHA_GOTTPREL
:
4969 r_type
= R_ALPHA_TPREL64
;
4971 case R_ALPHA_TLSLDM
:
4976 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4977 gotent
->got_offset
, h
->dynindx
,
4978 r_type
, gotent
->addend
);
4980 if (gotent
->reloc_type
== R_ALPHA_TLSGD
)
4981 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4982 gotent
->got_offset
+ 8, h
->dynindx
,
4983 R_ALPHA_DTPREL64
, gotent
->addend
);
4987 /* Mark some specially defined symbols as absolute. */
4988 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4989 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
4990 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4991 sym
->st_shndx
= SHN_ABS
;
4996 /* Finish up the dynamic sections. */
4999 elf64_alpha_finish_dynamic_sections (output_bfd
, info
)
5001 struct bfd_link_info
*info
;
5006 dynobj
= elf_hash_table (info
)->dynobj
;
5007 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5009 if (elf_hash_table (info
)->dynamic_sections_created
)
5012 Elf64_External_Dyn
*dyncon
, *dynconend
;
5014 splt
= bfd_get_section_by_name (dynobj
, ".plt");
5015 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
5017 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
5018 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5019 for (; dyncon
< dynconend
; dyncon
++)
5021 Elf_Internal_Dyn dyn
;
5025 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5040 /* My interpretation of the TIS v1.1 ELF document indicates
5041 that RELASZ should not include JMPREL. This is not what
5042 the rest of the BFD does. It is, however, what the
5043 glibc ld.so wants. Do this fixup here until we found
5044 out who is right. */
5045 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
5047 dyn
.d_un
.d_val
-= s
->size
;
5051 s
= bfd_get_section_by_name (output_bfd
, name
);
5052 dyn
.d_un
.d_ptr
= (s
? s
->vma
: 0);
5056 s
= bfd_get_section_by_name (output_bfd
, name
);
5057 dyn
.d_un
.d_val
= s
->size
;
5061 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5064 /* Initialize the PLT0 entry. */
5067 bfd_put_32 (output_bfd
, PLT_HEADER_WORD1
, splt
->contents
);
5068 bfd_put_32 (output_bfd
, PLT_HEADER_WORD2
, splt
->contents
+ 4);
5069 bfd_put_32 (output_bfd
, PLT_HEADER_WORD3
, splt
->contents
+ 8);
5070 bfd_put_32 (output_bfd
, PLT_HEADER_WORD4
, splt
->contents
+ 12);
5072 /* The next two words will be filled in by ld.so */
5073 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 16);
5074 bfd_put_64 (output_bfd
, (bfd_vma
) 0, splt
->contents
+ 24);
5076 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 0;
5083 /* We need to use a special link routine to handle the .mdebug section.
5084 We need to merge all instances of these sections together, not write
5085 them all out sequentially. */
5088 elf64_alpha_final_link (abfd
, info
)
5090 struct bfd_link_info
*info
;
5093 struct bfd_link_order
*p
;
5094 asection
*mdebug_sec
;
5095 struct ecoff_debug_info debug
;
5096 const struct ecoff_debug_swap
*swap
5097 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
5098 HDRR
*symhdr
= &debug
.symbolic_header
;
5099 PTR mdebug_handle
= NULL
;
5101 /* Go through the sections and collect the mdebug information. */
5103 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5105 if (strcmp (o
->name
, ".mdebug") == 0)
5107 struct extsym_info einfo
;
5109 /* We have found the .mdebug section in the output file.
5110 Look through all the link_orders comprising it and merge
5111 the information together. */
5112 symhdr
->magic
= swap
->sym_magic
;
5113 /* FIXME: What should the version stamp be? */
5115 symhdr
->ilineMax
= 0;
5119 symhdr
->isymMax
= 0;
5120 symhdr
->ioptMax
= 0;
5121 symhdr
->iauxMax
= 0;
5123 symhdr
->issExtMax
= 0;
5126 symhdr
->iextMax
= 0;
5128 /* We accumulate the debugging information itself in the
5129 debug_info structure. */
5131 debug
.external_dnr
= NULL
;
5132 debug
.external_pdr
= NULL
;
5133 debug
.external_sym
= NULL
;
5134 debug
.external_opt
= NULL
;
5135 debug
.external_aux
= NULL
;
5137 debug
.ssext
= debug
.ssext_end
= NULL
;
5138 debug
.external_fdr
= NULL
;
5139 debug
.external_rfd
= NULL
;
5140 debug
.external_ext
= debug
.external_ext_end
= NULL
;
5142 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
5143 if (mdebug_handle
== (PTR
) NULL
)
5152 static const char * const name
[] =
5154 ".text", ".init", ".fini", ".data",
5155 ".rodata", ".sdata", ".sbss", ".bss"
5157 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
5158 scRData
, scSData
, scSBss
, scBss
};
5161 esym
.cobol_main
= 0;
5165 esym
.asym
.iss
= issNil
;
5166 esym
.asym
.st
= stLocal
;
5167 esym
.asym
.reserved
= 0;
5168 esym
.asym
.index
= indexNil
;
5169 for (i
= 0; i
< 8; i
++)
5171 esym
.asym
.sc
= sc
[i
];
5172 s
= bfd_get_section_by_name (abfd
, name
[i
]);
5175 esym
.asym
.value
= s
->vma
;
5176 last
= s
->vma
+ s
->size
;
5179 esym
.asym
.value
= last
;
5181 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
5187 for (p
= o
->link_order_head
;
5188 p
!= (struct bfd_link_order
*) NULL
;
5191 asection
*input_section
;
5193 const struct ecoff_debug_swap
*input_swap
;
5194 struct ecoff_debug_info input_debug
;
5198 if (p
->type
!= bfd_indirect_link_order
)
5200 if (p
->type
== bfd_data_link_order
)
5205 input_section
= p
->u
.indirect
.section
;
5206 input_bfd
= input_section
->owner
;
5208 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
5209 || (get_elf_backend_data (input_bfd
)
5210 ->elf_backend_ecoff_debug_swap
) == NULL
)
5212 /* I don't know what a non ALPHA ELF bfd would be
5213 doing with a .mdebug section, but I don't really
5214 want to deal with it. */
5218 input_swap
= (get_elf_backend_data (input_bfd
)
5219 ->elf_backend_ecoff_debug_swap
);
5221 BFD_ASSERT (p
->size
== input_section
->size
);
5223 /* The ECOFF linking code expects that we have already
5224 read in the debugging information and set up an
5225 ecoff_debug_info structure, so we do that now. */
5226 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
5230 if (! (bfd_ecoff_debug_accumulate
5231 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
5232 &input_debug
, input_swap
, info
)))
5235 /* Loop through the external symbols. For each one with
5236 interesting information, try to find the symbol in
5237 the linker global hash table and save the information
5238 for the output external symbols. */
5239 eraw_src
= input_debug
.external_ext
;
5240 eraw_end
= (eraw_src
5241 + (input_debug
.symbolic_header
.iextMax
5242 * input_swap
->external_ext_size
));
5244 eraw_src
< eraw_end
;
5245 eraw_src
+= input_swap
->external_ext_size
)
5249 struct alpha_elf_link_hash_entry
*h
;
5251 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
5252 if (ext
.asym
.sc
== scNil
5253 || ext
.asym
.sc
== scUndefined
5254 || ext
.asym
.sc
== scSUndefined
)
5257 name
= input_debug
.ssext
+ ext
.asym
.iss
;
5258 h
= alpha_elf_link_hash_lookup (alpha_elf_hash_table (info
),
5259 name
, FALSE
, FALSE
, TRUE
);
5260 if (h
== NULL
|| h
->esym
.ifd
!= -2)
5266 < input_debug
.symbolic_header
.ifdMax
);
5267 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
5273 /* Free up the information we just read. */
5274 free (input_debug
.line
);
5275 free (input_debug
.external_dnr
);
5276 free (input_debug
.external_pdr
);
5277 free (input_debug
.external_sym
);
5278 free (input_debug
.external_opt
);
5279 free (input_debug
.external_aux
);
5280 free (input_debug
.ss
);
5281 free (input_debug
.ssext
);
5282 free (input_debug
.external_fdr
);
5283 free (input_debug
.external_rfd
);
5284 free (input_debug
.external_ext
);
5286 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5287 elf_link_input_bfd ignores this section. */
5288 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
5291 /* Build the external symbol information. */
5294 einfo
.debug
= &debug
;
5296 einfo
.failed
= FALSE
;
5297 elf_link_hash_traverse (elf_hash_table (info
),
5298 elf64_alpha_output_extsym
,
5303 /* Set the size of the .mdebug section. */
5304 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
5306 /* Skip this section later on (I don't think this currently
5307 matters, but someday it might). */
5308 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
5314 /* Invoke the regular ELF backend linker to do all the work. */
5315 if (! bfd_elf_final_link (abfd
, info
))
5318 /* Now write out the computed sections. */
5320 /* The .got subsections... */
5322 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
5323 for (i
= alpha_elf_hash_table(info
)->got_list
;
5325 i
= alpha_elf_tdata(i
)->got_link_next
)
5329 /* elf_bfd_final_link already did everything in dynobj. */
5333 sgot
= alpha_elf_tdata(i
)->got
;
5334 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
5336 (file_ptr
) sgot
->output_offset
,
5342 if (mdebug_sec
!= (asection
*) NULL
)
5344 BFD_ASSERT (abfd
->output_has_begun
);
5345 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5347 mdebug_sec
->filepos
))
5350 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5356 static enum elf_reloc_type_class
5357 elf64_alpha_reloc_type_class (rela
)
5358 const Elf_Internal_Rela
*rela
;
5360 switch ((int) ELF64_R_TYPE (rela
->r_info
))
5362 case R_ALPHA_RELATIVE
:
5363 return reloc_class_relative
;
5364 case R_ALPHA_JMP_SLOT
:
5365 return reloc_class_plt
;
5367 return reloc_class_copy
;
5369 return reloc_class_normal
;
5373 static struct bfd_elf_special_section
const elf64_alpha_special_sections
[]=
5375 { ".sdata", 6, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5376 { ".sbss", 5, -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5377 { NULL
, 0, 0, 0, 0 }
5380 /* ECOFF swapping routines. These are used when dealing with the
5381 .mdebug section, which is in the ECOFF debugging format. Copied
5382 from elf32-mips.c. */
5383 static const struct ecoff_debug_swap
5384 elf64_alpha_ecoff_debug_swap
=
5386 /* Symbol table magic number. */
5388 /* Alignment of debugging information. E.g., 4. */
5390 /* Sizes of external symbolic information. */
5391 sizeof (struct hdr_ext
),
5392 sizeof (struct dnr_ext
),
5393 sizeof (struct pdr_ext
),
5394 sizeof (struct sym_ext
),
5395 sizeof (struct opt_ext
),
5396 sizeof (struct fdr_ext
),
5397 sizeof (struct rfd_ext
),
5398 sizeof (struct ext_ext
),
5399 /* Functions to swap in external symbolic data. */
5408 _bfd_ecoff_swap_tir_in
,
5409 _bfd_ecoff_swap_rndx_in
,
5410 /* Functions to swap out external symbolic data. */
5419 _bfd_ecoff_swap_tir_out
,
5420 _bfd_ecoff_swap_rndx_out
,
5421 /* Function to read in symbolic data. */
5422 elf64_alpha_read_ecoff_info
5425 /* Use a non-standard hash bucket size of 8. */
5427 static const struct elf_size_info alpha_elf_size_info
=
5429 sizeof (Elf64_External_Ehdr
),
5430 sizeof (Elf64_External_Phdr
),
5431 sizeof (Elf64_External_Shdr
),
5432 sizeof (Elf64_External_Rel
),
5433 sizeof (Elf64_External_Rela
),
5434 sizeof (Elf64_External_Sym
),
5435 sizeof (Elf64_External_Dyn
),
5436 sizeof (Elf_External_Note
),
5440 ELFCLASS64
, EV_CURRENT
,
5441 bfd_elf64_write_out_phdrs
,
5442 bfd_elf64_write_shdrs_and_ehdr
,
5443 bfd_elf64_write_relocs
,
5444 bfd_elf64_swap_symbol_in
,
5445 bfd_elf64_swap_symbol_out
,
5446 bfd_elf64_slurp_reloc_table
,
5447 bfd_elf64_slurp_symbol_table
,
5448 bfd_elf64_swap_dyn_in
,
5449 bfd_elf64_swap_dyn_out
,
5450 bfd_elf64_swap_reloc_in
,
5451 bfd_elf64_swap_reloc_out
,
5452 bfd_elf64_swap_reloca_in
,
5453 bfd_elf64_swap_reloca_out
5456 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5457 #define TARGET_LITTLE_NAME "elf64-alpha"
5458 #define ELF_ARCH bfd_arch_alpha
5459 #define ELF_MACHINE_CODE EM_ALPHA
5460 #define ELF_MAXPAGESIZE 0x10000
5462 #define bfd_elf64_bfd_link_hash_table_create \
5463 elf64_alpha_bfd_link_hash_table_create
5465 #define bfd_elf64_bfd_reloc_type_lookup \
5466 elf64_alpha_bfd_reloc_type_lookup
5467 #define elf_info_to_howto \
5468 elf64_alpha_info_to_howto
5470 #define bfd_elf64_mkobject \
5471 elf64_alpha_mkobject
5472 #define elf_backend_object_p \
5473 elf64_alpha_object_p
5475 #define elf_backend_section_from_shdr \
5476 elf64_alpha_section_from_shdr
5477 #define elf_backend_section_flags \
5478 elf64_alpha_section_flags
5479 #define elf_backend_fake_sections \
5480 elf64_alpha_fake_sections
5482 #define bfd_elf64_bfd_is_local_label_name \
5483 elf64_alpha_is_local_label_name
5484 #define bfd_elf64_find_nearest_line \
5485 elf64_alpha_find_nearest_line
5486 #define bfd_elf64_bfd_relax_section \
5487 elf64_alpha_relax_section
5489 #define elf_backend_add_symbol_hook \
5490 elf64_alpha_add_symbol_hook
5491 #define elf_backend_check_relocs \
5492 elf64_alpha_check_relocs
5493 #define elf_backend_create_dynamic_sections \
5494 elf64_alpha_create_dynamic_sections
5495 #define elf_backend_adjust_dynamic_symbol \
5496 elf64_alpha_adjust_dynamic_symbol
5497 #define elf_backend_always_size_sections \
5498 elf64_alpha_always_size_sections
5499 #define elf_backend_size_dynamic_sections \
5500 elf64_alpha_size_dynamic_sections
5501 #define elf_backend_relocate_section \
5502 elf64_alpha_relocate_section
5503 #define elf_backend_finish_dynamic_symbol \
5504 elf64_alpha_finish_dynamic_symbol
5505 #define elf_backend_finish_dynamic_sections \
5506 elf64_alpha_finish_dynamic_sections
5507 #define bfd_elf64_bfd_final_link \
5508 elf64_alpha_final_link
5509 #define elf_backend_reloc_type_class \
5510 elf64_alpha_reloc_type_class
5512 #define elf_backend_ecoff_debug_swap \
5513 &elf64_alpha_ecoff_debug_swap
5515 #define elf_backend_size_info \
5518 #define elf_backend_special_sections \
5519 elf64_alpha_special_sections
5521 /* A few constants that determine how the .plt section is set up. */
5522 #define elf_backend_want_got_plt 0
5523 #define elf_backend_plt_readonly 0
5524 #define elf_backend_want_plt_sym 1
5525 #define elf_backend_got_header_size 0
5527 #include "elf64-target.h"
5529 /* FreeBSD support. */
5531 #undef TARGET_LITTLE_SYM
5532 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5533 #undef TARGET_LITTLE_NAME
5534 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5536 /* The kernel recognizes executables as valid only if they carry a
5537 "FreeBSD" label in the ELF header. So we put this label on all
5538 executables and (for simplicity) also all other object files. */
5540 static void elf64_alpha_fbsd_post_process_headers
5541 PARAMS ((bfd
*, struct bfd_link_info
*));
5544 elf64_alpha_fbsd_post_process_headers (abfd
, link_info
)
5546 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
5548 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
5550 i_ehdrp
= elf_elfheader (abfd
);
5552 /* Put an ABI label supported by FreeBSD >= 4.1. */
5553 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
5554 #ifdef OLD_FREEBSD_ABI_LABEL
5555 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5556 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5560 #undef elf_backend_post_process_headers
5561 #define elf_backend_post_process_headers \
5562 elf64_alpha_fbsd_post_process_headers
5565 #define elf64_bed elf64_alpha_fbsd_bed
5567 #include "elf64-target.h"