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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 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 & 0xffff) ^ 0x8000) - 0x8000;
1305 xdisp = disp + insn_disp;
1306 fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
1307 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
1308 && xdisp < 0x7fff8000);
1312 /* Take the op code and dest from this insn, take the base
1313 register from the literal insn. Leave the offset alone. */
1314 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1315 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1317 urel->r_addend = irel->r_addend;
1318 info->changed_relocs = TRUE;
1320 bfd_put_32 (info->abfd, (bfd_vma) insn,
1321 info->contents + urel->r_offset);
1322 info->changed_contents = TRUE;
1325 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1326 else if (fits32 && !(flags & ~6))
1328 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1330 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1332 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1333 bfd_put_32 (info->abfd, (bfd_vma) lit_insn,
1334 info->contents + irel->r_offset);
1336 info->changed_contents = TRUE;
1338 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1340 urel->r_addend = irel->r_addend;
1341 info->changed_relocs = TRUE;
1344 all_optimized = FALSE;
1347 case LITUSE_ALPHA_BYTOFF:
1348 /* We can always optimize byte instructions. */
1350 /* FIXME: sanity check the insn for byte op. Check that the
1351 literal dest reg is indeed Rb in the byte insn. */
1353 insn &= ~ (unsigned) 0x001ff000;
1354 insn |= ((symval & 7) << 13) | 0x1000;
1356 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1358 info->changed_relocs = TRUE;
1360 bfd_put_32 (info->abfd, (bfd_vma) insn,
1361 info->contents + urel->r_offset);
1362 info->changed_contents = TRUE;
1365 case LITUSE_ALPHA_JSR:
1366 case LITUSE_ALPHA_TLSGD:
1367 case LITUSE_ALPHA_TLSLDM:
1369 bfd_vma optdest, org;
1370 bfd_signed_vma odisp;
1372 /* For undefined weak symbols, we're mostly interested in getting
1373 rid of the got entry whenever possible, so optimize this to a
1374 use of the zero register. */
1375 if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
1378 bfd_put_32 (info->abfd, (bfd_vma) insn,
1379 info->contents + urel->r_offset);
1381 info->changed_contents = TRUE;
1385 /* If not zero, place to jump without needing pv. */
1386 optdest = elf64_alpha_relax_opt_call (info, symval);
1387 org = (info->sec->output_section->vma
1388 + info->sec->output_offset
1389 + urel->r_offset + 4);
1390 odisp = (optdest ? optdest : symval) - org;
1392 if (odisp >= -0x400000 && odisp < 0x400000)
1394 Elf_Internal_Rela *xrel;
1396 /* Preserve branch prediction call stack when possible. */
1397 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1398 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1400 insn = (OP_BR << 26) | (insn & 0x03e00000);
1402 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1404 urel->r_addend = irel->r_addend;
1407 urel->r_addend += optdest - symval;
1409 all_optimized = FALSE;
1411 bfd_put_32 (info->abfd, (bfd_vma) insn,
1412 info->contents + urel->r_offset);
1414 /* Kill any HINT reloc that might exist for this insn. */
1415 xrel = (elf64_alpha_find_reloc_at_ofs
1416 (info->relocs, info->relend, urel->r_offset,
1419 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1421 info->changed_contents = TRUE;
1422 info->changed_relocs = TRUE;
1425 all_optimized = FALSE;
1427 /* Even if the target is not in range for a direct branch,
1428 if we share a GP, we can eliminate the gp reload. */
1431 Elf_Internal_Rela *gpdisp
1432 = (elf64_alpha_find_reloc_at_ofs
1433 (info->relocs, irelend, urel->r_offset + 4,
1437 bfd_byte *p_ldah = info->contents + gpdisp->r_offset;
1438 bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
1439 unsigned int ldah = bfd_get_32 (info->abfd, p_ldah);
1440 unsigned int lda = bfd_get_32 (info->abfd, p_lda);
1442 /* Verify that the instruction is "ldah $29,0($26)".
1443 Consider a function that ends in a noreturn call,
1444 and that the next function begins with an ldgp,
1445 and that by accident there is no padding between.
1446 In that case the insn would use $27 as the base. */
1447 if (ldah == 0x27ba0000 && lda == 0x23bd0000)
1449 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_ldah);
1450 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, p_lda);
1452 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1453 info->changed_contents = TRUE;
1454 info->changed_relocs = TRUE;
1463 /* If all cases were optimized, we can reduce the use count on this
1464 got entry by one, possibly eliminating it. */
1467 if (--info->gotent->use_count == 0)
1469 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
1470 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1472 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
1475 /* If the literal instruction is no longer needed (it may have been
1476 reused. We can eliminate it. */
1477 /* ??? For now, I don't want to deal with compacting the section,
1478 so just nop it out. */
1481 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1482 info->changed_relocs = TRUE;
1484 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP,
1485 info->contents + irel->r_offset);
1486 info->changed_contents = TRUE;
1492 return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
1496 elf64_alpha_relax_opt_call (info, symval)
1497 struct alpha_relax_info *info;
1500 /* If the function has the same gp, and we can identify that the
1501 function does not use its function pointer, we can eliminate the
1504 /* If the symbol is marked NOPV, we are being told the function never
1505 needs its procedure value. */
1506 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1509 /* If the symbol is marked STD_GP, we are being told the function does
1510 a normal ldgp in the first two words. */
1511 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1514 /* Otherwise, we may be able to identify a GP load in the first two
1515 words, which we can then skip. */
1518 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1521 /* Load the relocations from the section that the target symbol is in. */
1522 if (info->sec == info->tsec)
1524 tsec_relocs = info->relocs;
1525 tsec_relend = info->relend;
1530 tsec_relocs = (_bfd_elf_link_read_relocs
1531 (info->abfd, info->tsec, (PTR) NULL,
1532 (Elf_Internal_Rela *) NULL,
1533 info->link_info->keep_memory));
1534 if (tsec_relocs == NULL)
1536 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1537 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1540 /* Recover the symbol's offset within the section. */
1541 ofs = (symval - info->tsec->output_section->vma
1542 - info->tsec->output_offset);
1544 /* Look for a GPDISP reloc. */
1545 gpdisp = (elf64_alpha_find_reloc_at_ofs
1546 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1548 if (!gpdisp || gpdisp->r_addend != 4)
1558 /* We've now determined that we can skip an initial gp load. Verify
1559 that the call and the target use the same gp. */
1560 if (info->link_info->hash->creator != info->tsec->owner->xvec
1561 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1568 elf64_alpha_relax_got_load (info, symval, irel, r_type)
1569 struct alpha_relax_info *info;
1571 Elf_Internal_Rela *irel;
1572 unsigned long r_type;
1575 bfd_signed_vma disp;
1577 /* Get the instruction. */
1578 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1580 if (insn >> 26 != OP_LDQ)
1582 reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
1583 ((*_bfd_error_handler)
1584 ("%B: %A+0x%lx: warning: %s relocation against unexpected insn",
1585 info->abfd, info->sec,
1586 (unsigned long) irel->r_offset, howto->name));
1590 /* Can't relax dynamic symbols. */
1591 if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
1594 /* Can't use local-exec relocations in shared libraries. */
1595 if (r_type == R_ALPHA_GOTTPREL && info->link_info->shared)
1598 if (r_type == R_ALPHA_LITERAL)
1600 /* Look for nice constant addresses. This includes the not-uncommon
1601 special case of 0 for undefweak symbols. */
1602 if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
1603 || (!info->link_info->shared
1604 && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
1607 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
1608 insn |= (symval & 0xffff);
1609 r_type = R_ALPHA_NONE;
1613 disp = symval - info->gp;
1614 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1615 r_type = R_ALPHA_GPREL16;
1620 bfd_vma dtp_base, tp_base;
1622 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
1623 dtp_base = alpha_get_dtprel_base (info->link_info);
1624 tp_base = alpha_get_tprel_base (info->link_info);
1625 disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
1627 insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
1631 case R_ALPHA_GOTDTPREL:
1632 r_type = R_ALPHA_DTPREL16;
1634 case R_ALPHA_GOTTPREL:
1635 r_type = R_ALPHA_TPREL16;
1643 if (disp < -0x8000 || disp >= 0x8000)
1646 bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
1647 info->changed_contents = TRUE;
1649 /* Reduce the use count on this got entry by one, possibly
1651 if (--info->gotent->use_count == 0)
1653 int sz = alpha_got_entry_size (r_type);
1654 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1656 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
1659 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
1660 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
1661 info->changed_relocs = TRUE;
1663 /* ??? Search forward through this basic block looking for insns
1664 that use the target register. Stop after an insn modifying the
1665 register is seen, or after a branch or call.
1667 Any such memory load insn may be substituted by a load directly
1668 off the GP. This allows the memory load insn to be issued before
1669 the calculated GP register would otherwise be ready.
1671 Any such jsr insn can be replaced by a bsr if it is in range.
1673 This would mean that we'd have to _add_ relocations, the pain of
1674 which gives one pause. */
1680 elf64_alpha_relax_gprelhilo (info, symval, irel, hi)
1681 struct alpha_relax_info *info;
1683 Elf_Internal_Rela *irel;
1687 bfd_signed_vma disp;
1688 bfd_byte *pos = info->contents + irel->r_offset;
1690 /* ??? This assumes that the compiler doesn't render
1694 ldah t, array(gp) !gprelhigh
1696 ldq r, array(t) !gprellow
1698 which would indeed be the most efficient way to implement this. */
1702 disp = symval - info->gp;
1703 if (disp < -0x8000 || disp >= 0x8000)
1708 /* Nop out the high instruction. */
1710 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos);
1711 info->changed_contents = TRUE;
1713 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1715 info->changed_relocs = TRUE;
1719 /* Adjust the low instruction to reference GP directly. */
1721 insn = bfd_get_32 (info->abfd, pos);
1722 insn = (insn & 0xffe00000) | (29 << 16);
1723 bfd_put_32 (info->abfd, (bfd_vma) insn, pos);
1724 info->changed_contents = TRUE;
1726 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1728 info->changed_relocs = TRUE;
1735 elf64_alpha_relax_tls_get_addr (info, symval, irel, is_gd)
1736 struct alpha_relax_info *info;
1738 Elf_Internal_Rela *irel;
1743 Elf_Internal_Rela *gpdisp, *hint;
1744 bfd_boolean dynamic, use_gottprel, pos1_unusable;
1745 unsigned long new_symndx;
1747 dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
1749 /* If a TLS symbol is accessed using IE at least once, there is no point
1750 to use dynamic model for it. */
1751 if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
1754 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
1755 then we might as well relax to IE. */
1756 else if (info->link_info->shared && !dynamic
1757 && (info->link_info->flags & DF_STATIC_TLS))
1760 /* Otherwise we must be building an executable to do anything. */
1761 else if (info->link_info->shared)
1764 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
1765 the matching LITUSE_TLS relocations. */
1766 if (irel + 2 >= info->relend)
1768 if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
1769 || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
1770 || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
1773 /* There must be a GPDISP relocation positioned immediately after the
1774 LITUSE relocation. */
1775 gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
1776 irel[2].r_offset + 4, R_ALPHA_GPDISP);
1780 pos[0] = info->contents + irel[0].r_offset;
1781 pos[1] = info->contents + irel[1].r_offset;
1782 pos[2] = info->contents + irel[2].r_offset;
1783 pos[3] = info->contents + gpdisp->r_offset;
1784 pos[4] = pos[3] + gpdisp->r_addend;
1785 pos1_unusable = FALSE;
1787 /* Generally, the positions are not allowed to be out of order, lest the
1788 modified insn sequence have different register lifetimes. We can make
1789 an exception when pos 1 is adjacent to pos 0. */
1790 if (pos[1] + 4 == pos[0])
1792 bfd_byte *tmp = pos[0];
1796 else if (pos[1] < pos[0])
1797 pos1_unusable = TRUE;
1798 if (pos[1] >= pos[2] || pos[2] >= pos[3])
1801 /* Reduce the use count on the LITERAL relocation. Do this before we
1802 smash the symndx when we adjust the relocations below. */
1804 struct alpha_elf_got_entry *lit_gotent;
1805 struct alpha_elf_link_hash_entry *lit_h;
1808 BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
1809 indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
1810 lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
1812 while (lit_h->root.root.type == bfd_link_hash_indirect
1813 || lit_h->root.root.type == bfd_link_hash_warning)
1814 lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
1816 for (lit_gotent = lit_h->got_entries; lit_gotent ;
1817 lit_gotent = lit_gotent->next)
1818 if (lit_gotent->gotobj == info->gotobj
1819 && lit_gotent->reloc_type == R_ALPHA_LITERAL
1820 && lit_gotent->addend == irel[1].r_addend)
1822 BFD_ASSERT (lit_gotent);
1824 if (--lit_gotent->use_count == 0)
1826 int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
1827 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1833 lda $16,x($gp) !tlsgd!1
1834 ldq $27,__tls_get_addr($gp) !literal!1
1835 jsr $26,($27)__tls_get_addr !lituse_tlsgd!1
1836 ldah $29,0($26) !gpdisp!2
1837 lda $29,0($29) !gpdisp!2
1839 ldq $16,x($gp) !gottprel
1844 or the first pair to
1845 lda $16,x($gp) !tprel
1848 ldah $16,x($gp) !tprelhi
1849 lda $16,x($16) !tprello
1853 use_gottprel = FALSE;
1854 new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : 0;
1855 switch (!dynamic && !info->link_info->shared)
1860 bfd_signed_vma disp;
1862 BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
1863 tp_base = alpha_get_tprel_base (info->link_info);
1864 disp = symval - tp_base;
1866 if (disp >= -0x8000 && disp < 0x8000)
1868 insn = (OP_LDA << 26) | (16 << 21) | (31 << 16);
1869 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
1870 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
1872 irel[0].r_offset = pos[0] - info->contents;
1873 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
1874 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1877 else if (disp >= -(bfd_signed_vma) 0x80000000
1878 && disp < (bfd_signed_vma) 0x7fff8000
1881 insn = (OP_LDAH << 26) | (16 << 21) | (31 << 16);
1882 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
1883 insn = (OP_LDA << 26) | (16 << 21) | (16 << 16);
1884 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
1886 irel[0].r_offset = pos[0] - info->contents;
1887 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
1888 irel[1].r_offset = pos[1] - info->contents;
1889 irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
1896 use_gottprel = TRUE;
1898 insn = (OP_LDQ << 26) | (16 << 21) | (29 << 16);
1899 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
1900 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
1902 irel[0].r_offset = pos[0] - info->contents;
1903 irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
1904 irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1908 bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
1910 insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
1911 bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
1913 bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
1915 irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1916 gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1918 hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
1919 irel[2].r_offset, R_ALPHA_HINT);
1921 hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1923 info->changed_contents = TRUE;
1924 info->changed_relocs = TRUE;
1926 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
1927 if (--info->gotent->use_count == 0)
1929 int sz = alpha_got_entry_size (info->gotent->reloc_type);
1930 alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
1932 alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
1935 /* If we've switched to a GOTTPREL relocation, increment the reference
1936 count on that got entry. */
1939 struct alpha_elf_got_entry *tprel_gotent;
1941 for (tprel_gotent = *info->first_gotent; tprel_gotent ;
1942 tprel_gotent = tprel_gotent->next)
1943 if (tprel_gotent->gotobj == info->gotobj
1944 && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
1945 && tprel_gotent->addend == irel->r_addend)
1948 tprel_gotent->use_count++;
1951 if (info->gotent->use_count == 0)
1952 tprel_gotent = info->gotent;
1955 tprel_gotent = (struct alpha_elf_got_entry *)
1956 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
1960 tprel_gotent->next = *info->first_gotent;
1961 *info->first_gotent = tprel_gotent;
1963 tprel_gotent->gotobj = info->gotobj;
1964 tprel_gotent->addend = irel->r_addend;
1965 tprel_gotent->got_offset = -1;
1966 tprel_gotent->reloc_done = 0;
1967 tprel_gotent->reloc_xlated = 0;
1970 tprel_gotent->use_count = 1;
1971 tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
1979 elf64_alpha_relax_section (abfd, sec, link_info, again)
1982 struct bfd_link_info *link_info;
1985 Elf_Internal_Shdr *symtab_hdr;
1986 Elf_Internal_Rela *internal_relocs;
1987 Elf_Internal_Rela *irel, *irelend;
1988 Elf_Internal_Sym *isymbuf = NULL;
1989 struct alpha_elf_got_entry **local_got_entries;
1990 struct alpha_relax_info info;
1992 /* We are not currently changing any sizes, so only one pass. */
1995 if (link_info->relocatable
1996 || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
1997 != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
1998 || sec->reloc_count == 0)
2001 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2002 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2004 /* Load the relocations for this section. */
2005 internal_relocs = (_bfd_elf_link_read_relocs
2006 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2007 link_info->keep_memory));
2008 if (internal_relocs == NULL)
2011 memset(&info, 0, sizeof (info));
2014 info.link_info = link_info;
2015 info.symtab_hdr = symtab_hdr;
2016 info.relocs = internal_relocs;
2017 info.relend = irelend = internal_relocs + sec->reloc_count;
2019 /* Find the GP for this object. Do not store the result back via
2020 _bfd_set_gp_value, since this could change again before final. */
2021 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
2024 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
2025 info.gp = (sgot->output_section->vma
2026 + sgot->output_offset
2030 /* Get the section contents. */
2031 if (elf_section_data (sec)->this_hdr.contents != NULL)
2032 info.contents = elf_section_data (sec)->this_hdr.contents;
2035 if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
2039 for (irel = internal_relocs; irel < irelend; irel++)
2042 struct alpha_elf_got_entry *gotent;
2043 unsigned long r_type = ELF64_R_TYPE (irel->r_info);
2044 unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
2046 /* Early exit for unhandled or unrelaxable relocations. */
2049 case R_ALPHA_LITERAL:
2050 case R_ALPHA_GPRELHIGH:
2051 case R_ALPHA_GPRELLOW:
2052 case R_ALPHA_GOTDTPREL:
2053 case R_ALPHA_GOTTPREL:
2057 case R_ALPHA_TLSLDM:
2058 /* The symbol for a TLSLDM reloc is ignored. Collapse the
2059 reloc to the 0 symbol so that they all match. */
2067 /* Get the value of the symbol referred to by the reloc. */
2068 if (r_symndx < symtab_hdr->sh_info)
2070 /* A local symbol. */
2071 Elf_Internal_Sym *isym;
2073 /* Read this BFD's local symbols. */
2074 if (isymbuf == NULL)
2076 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2077 if (isymbuf == NULL)
2078 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2079 symtab_hdr->sh_info, 0,
2081 if (isymbuf == NULL)
2085 isym = isymbuf + r_symndx;
2087 /* Given the symbol for a TLSLDM reloc is ignored, this also
2088 means forcing the symbol value to the tp base. */
2089 if (r_type == R_ALPHA_TLSLDM)
2091 info.tsec = bfd_abs_section_ptr;
2092 symval = alpha_get_tprel_base (info.link_info);
2096 symval = isym->st_value;
2097 if (isym->st_shndx == SHN_UNDEF)
2099 else if (isym->st_shndx == SHN_ABS)
2100 info.tsec = bfd_abs_section_ptr;
2101 else if (isym->st_shndx == SHN_COMMON)
2102 info.tsec = bfd_com_section_ptr;
2104 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2108 info.other = isym->st_other;
2109 if (local_got_entries)
2110 info.first_gotent = &local_got_entries[r_symndx];
2113 info.first_gotent = &info.gotent;
2120 struct alpha_elf_link_hash_entry *h;
2122 indx = r_symndx - symtab_hdr->sh_info;
2123 h = alpha_elf_sym_hashes (abfd)[indx];
2124 BFD_ASSERT (h != NULL);
2126 while (h->root.root.type == bfd_link_hash_indirect
2127 || h->root.root.type == bfd_link_hash_warning)
2128 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2130 /* If the symbol is undefined, we can't do anything with it. */
2131 if (h->root.root.type == bfd_link_hash_undefined)
2134 /* If the symbol isn't defined in the current module,
2135 again we can't do anything. */
2136 if (h->root.root.type == bfd_link_hash_undefweak)
2138 info.tsec = bfd_abs_section_ptr;
2141 else if (!h->root.def_regular)
2143 /* Except for TLSGD relocs, which can sometimes be
2144 relaxed to GOTTPREL relocs. */
2145 if (r_type != R_ALPHA_TLSGD)
2147 info.tsec = bfd_abs_section_ptr;
2152 info.tsec = h->root.root.u.def.section;
2153 symval = h->root.root.u.def.value;
2157 info.other = h->root.other;
2158 info.first_gotent = &h->got_entries;
2161 /* Search for the got entry to be used by this relocation. */
2162 for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
2163 if (gotent->gotobj == info.gotobj
2164 && gotent->reloc_type == r_type
2165 && gotent->addend == irel->r_addend)
2167 info.gotent = gotent;
2169 symval += info.tsec->output_section->vma + info.tsec->output_offset;
2170 symval += irel->r_addend;
2174 case R_ALPHA_LITERAL:
2175 BFD_ASSERT(info.gotent != NULL);
2177 /* If there exist LITUSE relocations immediately following, this
2178 opens up all sorts of interesting optimizations, because we
2179 now know every location that this address load is used. */
2180 if (irel+1 < irelend
2181 && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
2183 if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
2188 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
2193 case R_ALPHA_GPRELHIGH:
2194 case R_ALPHA_GPRELLOW:
2195 if (!elf64_alpha_relax_gprelhilo (&info, symval, irel,
2196 r_type == R_ALPHA_GPRELHIGH))
2200 case R_ALPHA_GOTDTPREL:
2201 case R_ALPHA_GOTTPREL:
2202 BFD_ASSERT(info.gotent != NULL);
2203 if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
2208 case R_ALPHA_TLSLDM:
2209 BFD_ASSERT(info.gotent != NULL);
2210 if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
2211 r_type == R_ALPHA_TLSGD))
2217 if (!elf64_alpha_size_plt_section (link_info))
2219 if (!elf64_alpha_size_got_sections (link_info))
2221 if (!elf64_alpha_size_rela_got_section (link_info))
2225 && symtab_hdr->contents != (unsigned char *) isymbuf)
2227 if (!link_info->keep_memory)
2231 /* Cache the symbols for elf_link_input_bfd. */
2232 symtab_hdr->contents = (unsigned char *) isymbuf;
2236 if (info.contents != NULL
2237 && elf_section_data (sec)->this_hdr.contents != info.contents)
2239 if (!info.changed_contents && !link_info->keep_memory)
2240 free (info.contents);
2243 /* Cache the section contents for elf_link_input_bfd. */
2244 elf_section_data (sec)->this_hdr.contents = info.contents;
2248 if (elf_section_data (sec)->relocs != internal_relocs)
2250 if (!info.changed_relocs)
2251 free (internal_relocs);
2253 elf_section_data (sec)->relocs = internal_relocs;
2256 *again = info.changed_contents || info.changed_relocs;
2262 && symtab_hdr->contents != (unsigned char *) isymbuf)
2264 if (info.contents != NULL
2265 && elf_section_data (sec)->this_hdr.contents != info.contents)
2266 free (info.contents);
2267 if (internal_relocs != NULL
2268 && elf_section_data (sec)->relocs != internal_relocs)
2269 free (internal_relocs);
2274 #define PLT_HEADER_SIZE 32
2275 #define PLT_HEADER_WORD1 (bfd_vma) 0xc3600000 /* br $27,.+4 */
2276 #define PLT_HEADER_WORD2 (bfd_vma) 0xa77b000c /* ldq $27,12($27) */
2277 #define PLT_HEADER_WORD3 (bfd_vma) 0x47ff041f /* nop */
2278 #define PLT_HEADER_WORD4 (bfd_vma) 0x6b7b0000 /* jmp $27,($27) */
2280 #define PLT_ENTRY_SIZE 12
2281 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
2282 #define PLT_ENTRY_WORD2 0
2283 #define PLT_ENTRY_WORD3 0
2285 #define MAX_GOT_SIZE (64*1024)
2287 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
2289 /* Handle an Alpha specific section when reading an object file. This
2290 is called when bfd_section_from_shdr finds a section with an unknown
2292 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
2296 elf64_alpha_section_from_shdr (bfd *abfd,
2297 Elf_Internal_Shdr *hdr,
2303 /* There ought to be a place to keep ELF backend specific flags, but
2304 at the moment there isn't one. We just keep track of the
2305 sections by their name, instead. Fortunately, the ABI gives
2306 suggested names for all the MIPS specific sections, so we will
2307 probably get away with this. */
2308 switch (hdr->sh_type)
2310 case SHT_ALPHA_DEBUG:
2311 if (strcmp (name, ".mdebug") != 0)
2318 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2320 newsect = hdr->bfd_section;
2322 if (hdr->sh_type == SHT_ALPHA_DEBUG)
2324 if (! bfd_set_section_flags (abfd, newsect,
2325 (bfd_get_section_flags (abfd, newsect)
2333 /* Convert Alpha specific section flags to bfd internal section flags. */
2336 elf64_alpha_section_flags (flags, hdr)
2338 const Elf_Internal_Shdr *hdr;
2340 if (hdr->sh_flags & SHF_ALPHA_GPREL)
2341 *flags |= SEC_SMALL_DATA;
2346 /* Set the correct type for an Alpha ELF section. We do this by the
2347 section name, which is a hack, but ought to work. */
2350 elf64_alpha_fake_sections (abfd, hdr, sec)
2352 Elf_Internal_Shdr *hdr;
2355 register const char *name;
2357 name = bfd_get_section_name (abfd, sec);
2359 if (strcmp (name, ".mdebug") == 0)
2361 hdr->sh_type = SHT_ALPHA_DEBUG;
2362 /* In a shared object on Irix 5.3, the .mdebug section has an
2363 entsize of 0. FIXME: Does this matter? */
2364 if ((abfd->flags & DYNAMIC) != 0 )
2365 hdr->sh_entsize = 0;
2367 hdr->sh_entsize = 1;
2369 else if ((sec->flags & SEC_SMALL_DATA)
2370 || strcmp (name, ".sdata") == 0
2371 || strcmp (name, ".sbss") == 0
2372 || strcmp (name, ".lit4") == 0
2373 || strcmp (name, ".lit8") == 0)
2374 hdr->sh_flags |= SHF_ALPHA_GPREL;
2379 /* Hook called by the linker routine which adds symbols from an object
2380 file. We use it to put .comm items in .sbss, and not .bss. */
2383 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2385 struct bfd_link_info *info;
2386 Elf_Internal_Sym *sym;
2387 const char **namep ATTRIBUTE_UNUSED;
2388 flagword *flagsp ATTRIBUTE_UNUSED;
2392 if (sym->st_shndx == SHN_COMMON
2393 && !info->relocatable
2394 && sym->st_size <= elf_gp_size (abfd))
2396 /* Common symbols less than or equal to -G nn bytes are
2397 automatically put into .sbss. */
2399 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
2403 scomm = bfd_make_section_with_flags (abfd, ".scommon",
2406 | SEC_LINKER_CREATED));
2412 *valp = sym->st_size;
2418 /* Create the .got section. */
2421 elf64_alpha_create_got_section(abfd, info)
2423 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2427 if ((s = bfd_get_section_by_name (abfd, ".got")))
2429 /* Check for a non-linker created .got? */
2430 if (alpha_elf_tdata (abfd)->got == NULL)
2431 alpha_elf_tdata (abfd)->got = s;
2435 s = bfd_make_section_with_flags (abfd, ".got", (SEC_ALLOC | SEC_LOAD
2438 | SEC_LINKER_CREATED));
2440 || !bfd_set_section_alignment (abfd, s, 3))
2443 alpha_elf_tdata (abfd)->got = s;
2448 /* Create all the dynamic sections. */
2451 elf64_alpha_create_dynamic_sections (abfd, info)
2453 struct bfd_link_info *info;
2456 struct elf_link_hash_entry *h;
2457 struct bfd_link_hash_entry *bh;
2459 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
2461 s = bfd_make_section_with_flags (abfd, ".plt",
2462 (SEC_ALLOC | SEC_LOAD
2465 | SEC_LINKER_CREATED
2468 || ! bfd_set_section_alignment (abfd, s, 3))
2471 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2474 if (! (_bfd_generic_link_add_one_symbol
2475 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2476 (bfd_vma) 0, (const char *) NULL, FALSE,
2477 get_elf_backend_data (abfd)->collect, &bh)))
2479 h = (struct elf_link_hash_entry *) bh;
2481 h->type = STT_OBJECT;
2484 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2487 s = bfd_make_section_with_flags (abfd, ".rela.plt",
2488 (SEC_ALLOC | SEC_LOAD
2491 | SEC_LINKER_CREATED
2494 || ! bfd_set_section_alignment (abfd, s, 3))
2497 /* We may or may not have created a .got section for this object, but
2498 we definitely havn't done the rest of the work. */
2500 if (!elf64_alpha_create_got_section (abfd, info))
2503 s = bfd_make_section_with_flags (abfd, ".rela.got",
2504 (SEC_ALLOC | SEC_LOAD
2507 | SEC_LINKER_CREATED
2510 || !bfd_set_section_alignment (abfd, s, 3))
2513 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
2514 dynobj's .got section. We don't do this in the linker script
2515 because we don't want to define the symbol if we are not creating
2516 a global offset table. */
2518 if (!(_bfd_generic_link_add_one_symbol
2519 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
2520 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
2521 FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2523 h = (struct elf_link_hash_entry *) bh;
2525 h->type = STT_OBJECT;
2528 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2531 elf_hash_table (info)->hgot = h;
2536 /* Read ECOFF debugging information from a .mdebug section into a
2537 ecoff_debug_info structure. */
2540 elf64_alpha_read_ecoff_info (abfd, section, debug)
2543 struct ecoff_debug_info *debug;
2546 const struct ecoff_debug_swap *swap;
2547 char *ext_hdr = NULL;
2549 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2550 memset (debug, 0, sizeof (*debug));
2552 ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
2553 if (ext_hdr == NULL && swap->external_hdr_size != 0)
2556 if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
2557 swap->external_hdr_size))
2560 symhdr = &debug->symbolic_header;
2561 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
2563 /* The symbolic header contains absolute file offsets and sizes to
2565 #define READ(ptr, offset, count, size, type) \
2566 if (symhdr->count == 0) \
2567 debug->ptr = NULL; \
2570 bfd_size_type amt = (bfd_size_type) size * symhdr->count; \
2571 debug->ptr = (type) bfd_malloc (amt); \
2572 if (debug->ptr == NULL) \
2573 goto error_return; \
2574 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2575 || bfd_bread (debug->ptr, amt, abfd) != amt) \
2576 goto error_return; \
2579 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
2580 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
2581 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
2582 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
2583 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2584 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2586 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2587 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2588 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2589 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2590 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2598 if (ext_hdr != NULL)
2600 if (debug->line != NULL)
2602 if (debug->external_dnr != NULL)
2603 free (debug->external_dnr);
2604 if (debug->external_pdr != NULL)
2605 free (debug->external_pdr);
2606 if (debug->external_sym != NULL)
2607 free (debug->external_sym);
2608 if (debug->external_opt != NULL)
2609 free (debug->external_opt);
2610 if (debug->external_aux != NULL)
2611 free (debug->external_aux);
2612 if (debug->ss != NULL)
2614 if (debug->ssext != NULL)
2615 free (debug->ssext);
2616 if (debug->external_fdr != NULL)
2617 free (debug->external_fdr);
2618 if (debug->external_rfd != NULL)
2619 free (debug->external_rfd);
2620 if (debug->external_ext != NULL)
2621 free (debug->external_ext);
2625 /* Alpha ELF local labels start with '$'. */
2628 elf64_alpha_is_local_label_name (abfd, name)
2629 bfd *abfd ATTRIBUTE_UNUSED;
2632 return name[0] == '$';
2635 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2636 routine in order to handle the ECOFF debugging information. We
2637 still call this mips_elf_find_line because of the slot
2638 find_line_info in elf_obj_tdata is declared that way. */
2640 struct mips_elf_find_line
2642 struct ecoff_debug_info d;
2643 struct ecoff_find_line i;
2647 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2648 functionname_ptr, line_ptr)
2653 const char **filename_ptr;
2654 const char **functionname_ptr;
2655 unsigned int *line_ptr;
2659 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2660 filename_ptr, functionname_ptr,
2662 &elf_tdata (abfd)->dwarf2_find_line_info))
2665 msec = bfd_get_section_by_name (abfd, ".mdebug");
2669 struct mips_elf_find_line *fi;
2670 const struct ecoff_debug_swap * const swap =
2671 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2673 /* If we are called during a link, alpha_elf_final_link may have
2674 cleared the SEC_HAS_CONTENTS field. We force it back on here
2675 if appropriate (which it normally will be). */
2676 origflags = msec->flags;
2677 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2678 msec->flags |= SEC_HAS_CONTENTS;
2680 fi = elf_tdata (abfd)->find_line_info;
2683 bfd_size_type external_fdr_size;
2686 struct fdr *fdr_ptr;
2687 bfd_size_type amt = sizeof (struct mips_elf_find_line);
2689 fi = (struct mips_elf_find_line *) bfd_zalloc (abfd, amt);
2692 msec->flags = origflags;
2696 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2698 msec->flags = origflags;
2702 /* Swap in the FDR information. */
2703 amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
2704 fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
2705 if (fi->d.fdr == NULL)
2707 msec->flags = origflags;
2710 external_fdr_size = swap->external_fdr_size;
2711 fdr_ptr = fi->d.fdr;
2712 fraw_src = (char *) fi->d.external_fdr;
2713 fraw_end = (fraw_src
2714 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2715 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2716 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2718 elf_tdata (abfd)->find_line_info = fi;
2720 /* Note that we don't bother to ever free this information.
2721 find_nearest_line is either called all the time, as in
2722 objdump -l, so the information should be saved, or it is
2723 rarely called, as in ld error messages, so the memory
2724 wasted is unimportant. Still, it would probably be a
2725 good idea for free_cached_info to throw it away. */
2728 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2729 &fi->i, filename_ptr, functionname_ptr,
2732 msec->flags = origflags;
2736 msec->flags = origflags;
2739 /* Fall back on the generic ELF find_nearest_line routine. */
2741 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2742 filename_ptr, functionname_ptr,
2746 /* Structure used to pass information to alpha_elf_output_extsym. */
2751 struct bfd_link_info *info;
2752 struct ecoff_debug_info *debug;
2753 const struct ecoff_debug_swap *swap;
2758 elf64_alpha_output_extsym (h, data)
2759 struct alpha_elf_link_hash_entry *h;
2762 struct extsym_info *einfo = (struct extsym_info *) data;
2764 asection *sec, *output_section;
2766 if (h->root.root.type == bfd_link_hash_warning)
2767 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
2769 if (h->root.indx == -2)
2771 else if ((h->root.def_dynamic
2772 || h->root.ref_dynamic
2773 || h->root.root.type == bfd_link_hash_new)
2774 && !h->root.def_regular
2775 && !h->root.ref_regular)
2777 else if (einfo->info->strip == strip_all
2778 || (einfo->info->strip == strip_some
2779 && bfd_hash_lookup (einfo->info->keep_hash,
2780 h->root.root.root.string,
2781 FALSE, FALSE) == NULL))
2789 if (h->esym.ifd == -2)
2792 h->esym.cobol_main = 0;
2793 h->esym.weakext = 0;
2794 h->esym.reserved = 0;
2795 h->esym.ifd = ifdNil;
2796 h->esym.asym.value = 0;
2797 h->esym.asym.st = stGlobal;
2799 if (h->root.root.type != bfd_link_hash_defined
2800 && h->root.root.type != bfd_link_hash_defweak)
2801 h->esym.asym.sc = scAbs;
2806 sec = h->root.root.u.def.section;
2807 output_section = sec->output_section;
2809 /* When making a shared library and symbol h is the one from
2810 the another shared library, OUTPUT_SECTION may be null. */
2811 if (output_section == NULL)
2812 h->esym.asym.sc = scUndefined;
2815 name = bfd_section_name (output_section->owner, output_section);
2817 if (strcmp (name, ".text") == 0)
2818 h->esym.asym.sc = scText;
2819 else if (strcmp (name, ".data") == 0)
2820 h->esym.asym.sc = scData;
2821 else if (strcmp (name, ".sdata") == 0)
2822 h->esym.asym.sc = scSData;
2823 else if (strcmp (name, ".rodata") == 0
2824 || strcmp (name, ".rdata") == 0)
2825 h->esym.asym.sc = scRData;
2826 else if (strcmp (name, ".bss") == 0)
2827 h->esym.asym.sc = scBss;
2828 else if (strcmp (name, ".sbss") == 0)
2829 h->esym.asym.sc = scSBss;
2830 else if (strcmp (name, ".init") == 0)
2831 h->esym.asym.sc = scInit;
2832 else if (strcmp (name, ".fini") == 0)
2833 h->esym.asym.sc = scFini;
2835 h->esym.asym.sc = scAbs;
2839 h->esym.asym.reserved = 0;
2840 h->esym.asym.index = indexNil;
2843 if (h->root.root.type == bfd_link_hash_common)
2844 h->esym.asym.value = h->root.root.u.c.size;
2845 else if (h->root.root.type == bfd_link_hash_defined
2846 || h->root.root.type == bfd_link_hash_defweak)
2848 if (h->esym.asym.sc == scCommon)
2849 h->esym.asym.sc = scBss;
2850 else if (h->esym.asym.sc == scSCommon)
2851 h->esym.asym.sc = scSBss;
2853 sec = h->root.root.u.def.section;
2854 output_section = sec->output_section;
2855 if (output_section != NULL)
2856 h->esym.asym.value = (h->root.root.u.def.value
2857 + sec->output_offset
2858 + output_section->vma);
2860 h->esym.asym.value = 0;
2862 else if (h->root.needs_plt)
2864 /* Set type and value for a symbol with a function stub. */
2865 h->esym.asym.st = stProc;
2866 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2868 h->esym.asym.value = 0;
2871 output_section = sec->output_section;
2872 if (output_section != NULL)
2873 h->esym.asym.value = (h->root.plt.offset
2874 + sec->output_offset
2875 + output_section->vma);
2877 h->esym.asym.value = 0;
2881 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2882 h->root.root.root.string,
2885 einfo->failed = TRUE;
2892 /* Search for and possibly create a got entry. */
2894 static struct alpha_elf_got_entry *
2895 get_got_entry (abfd, h, r_type, r_symndx, r_addend)
2897 struct alpha_elf_link_hash_entry *h;
2898 unsigned long r_type, r_symndx;
2901 struct alpha_elf_got_entry *gotent;
2902 struct alpha_elf_got_entry **slot;
2905 slot = &h->got_entries;
2908 /* This is a local .got entry -- record for merge. */
2910 struct alpha_elf_got_entry **local_got_entries;
2912 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2913 if (!local_got_entries)
2916 Elf_Internal_Shdr *symtab_hdr;
2918 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2919 size = symtab_hdr->sh_info;
2920 size *= sizeof (struct alpha_elf_got_entry *);
2923 = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
2924 if (!local_got_entries)
2927 alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
2930 slot = &local_got_entries[r_symndx];
2933 for (gotent = *slot; gotent ; gotent = gotent->next)
2934 if (gotent->gotobj == abfd
2935 && gotent->reloc_type == r_type
2936 && gotent->addend == r_addend)
2944 amt = sizeof (struct alpha_elf_got_entry);
2945 gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
2949 gotent->gotobj = abfd;
2950 gotent->addend = r_addend;
2951 gotent->got_offset = -1;
2952 gotent->use_count = 1;
2953 gotent->reloc_type = r_type;
2954 gotent->reloc_done = 0;
2955 gotent->reloc_xlated = 0;
2957 gotent->next = *slot;
2960 entry_size = alpha_got_entry_size (r_type);
2961 alpha_elf_tdata (abfd)->total_got_size += entry_size;
2963 alpha_elf_tdata(abfd)->local_got_size += entry_size;
2966 gotent->use_count += 1;
2971 /* Handle dynamic relocations when doing an Alpha ELF link. */
2974 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2976 struct bfd_link_info *info;
2978 const Elf_Internal_Rela *relocs;
2982 const char *rel_sec_name;
2983 Elf_Internal_Shdr *symtab_hdr;
2984 struct alpha_elf_link_hash_entry **sym_hashes;
2985 const Elf_Internal_Rela *rel, *relend;
2986 bfd_boolean got_created;
2989 if (info->relocatable)
2992 /* Don't do anything special with non-loaded, non-alloced sections.
2993 In particular, any relocs in such sections should not affect GOT
2994 and PLT reference counting (ie. we don't allow them to create GOT
2995 or PLT entries), there's no possibility or desire to optimize TLS
2996 relocs, and there's not much point in propagating relocs to shared
2997 libs that the dynamic linker won't relocate. */
2998 if ((sec->flags & SEC_ALLOC) == 0)
3001 dynobj = elf_hash_table(info)->dynobj;
3003 elf_hash_table(info)->dynobj = dynobj = abfd;
3006 rel_sec_name = NULL;
3007 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
3008 sym_hashes = alpha_elf_sym_hashes(abfd);
3009 got_created = FALSE;
3011 relend = relocs + sec->reloc_count;
3012 for (rel = relocs; rel < relend; ++rel)
3020 unsigned long r_symndx, r_type;
3021 struct alpha_elf_link_hash_entry *h;
3022 unsigned int gotent_flags;
3023 bfd_boolean maybe_dynamic;
3027 r_symndx = ELF64_R_SYM (rel->r_info);
3028 if (r_symndx < symtab_hdr->sh_info)
3032 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3034 while (h->root.root.type == bfd_link_hash_indirect
3035 || h->root.root.type == bfd_link_hash_warning)
3036 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3038 h->root.ref_regular = 1;
3041 /* We can only get preliminary data on whether a symbol is
3042 locally or externally defined, as not all of the input files
3043 have yet been processed. Do something with what we know, as
3044 this may help reduce memory usage and processing time later. */
3045 maybe_dynamic = FALSE;
3046 if (h && ((info->shared
3047 && (!info->symbolic || info->unresolved_syms_in_shared_libs == RM_IGNORE))
3048 || !h->root.def_regular
3049 || h->root.root.type == bfd_link_hash_defweak))
3050 maybe_dynamic = TRUE;
3054 r_type = ELF64_R_TYPE (rel->r_info);
3055 addend = rel->r_addend;
3059 case R_ALPHA_LITERAL:
3060 need = NEED_GOT | NEED_GOT_ENTRY;
3062 /* Remember how this literal is used from its LITUSEs.
3063 This will be important when it comes to decide if we can
3064 create a .plt entry for a function symbol. */
3065 while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
3066 if (rel->r_addend >= 1 && rel->r_addend <= 5)
3067 gotent_flags |= 1 << rel->r_addend;
3070 /* No LITUSEs -- presumably the address is used somehow. */
3071 if (gotent_flags == 0)
3072 gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
3075 case R_ALPHA_GPDISP:
3076 case R_ALPHA_GPREL16:
3077 case R_ALPHA_GPREL32:
3078 case R_ALPHA_GPRELHIGH:
3079 case R_ALPHA_GPRELLOW:
3084 case R_ALPHA_REFLONG:
3085 case R_ALPHA_REFQUAD:
3086 if (info->shared || maybe_dynamic)
3090 case R_ALPHA_TLSLDM:
3091 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3092 reloc to the 0 symbol so that they all match. */
3095 maybe_dynamic = FALSE;
3099 case R_ALPHA_GOTDTPREL:
3100 need = NEED_GOT | NEED_GOT_ENTRY;
3103 case R_ALPHA_GOTTPREL:
3104 need = NEED_GOT | NEED_GOT_ENTRY;
3105 gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
3107 info->flags |= DF_STATIC_TLS;
3110 case R_ALPHA_TPREL64:
3111 if (info->shared || maybe_dynamic)
3114 info->flags |= DF_STATIC_TLS;
3118 if (need & NEED_GOT)
3122 if (!elf64_alpha_create_got_section (abfd, info))
3125 /* Make sure the object's gotobj is set to itself so
3126 that we default to every object with its own .got.
3127 We'll merge .gots later once we've collected each
3129 alpha_elf_tdata(abfd)->gotobj = abfd;
3135 if (need & NEED_GOT_ENTRY)
3137 struct alpha_elf_got_entry *gotent;
3139 gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
3145 gotent->flags |= gotent_flags;
3148 gotent_flags |= h->flags;
3149 h->flags = gotent_flags;
3151 /* Make a guess as to whether a .plt entry is needed. */
3152 if ((gotent_flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3153 && !(gotent_flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC))
3154 h->root.needs_plt = 1;
3156 h->root.needs_plt = 0;
3161 if (need & NEED_DYNREL)
3163 if (rel_sec_name == NULL)
3165 rel_sec_name = (bfd_elf_string_from_elf_section
3166 (abfd, elf_elfheader(abfd)->e_shstrndx,
3167 elf_section_data(sec)->rel_hdr.sh_name));
3168 if (rel_sec_name == NULL)
3171 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
3172 && strcmp (bfd_get_section_name (abfd, sec),
3173 rel_sec_name+5) == 0);
3176 /* We need to create the section here now whether we eventually
3177 use it or not so that it gets mapped to an output section by
3178 the linker. If not used, we'll kill it in
3179 size_dynamic_sections. */
3182 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
3187 flags = (SEC_HAS_CONTENTS | SEC_IN_MEMORY
3188 | SEC_LINKER_CREATED | SEC_READONLY);
3189 if (sec->flags & SEC_ALLOC)
3190 flags |= SEC_ALLOC | SEC_LOAD;
3191 sreloc = bfd_make_section_with_flags (dynobj,
3195 || !bfd_set_section_alignment (dynobj, sreloc, 3))
3202 /* Since we havn't seen all of the input symbols yet, we
3203 don't know whether we'll actually need a dynamic relocation
3204 entry for this reloc. So make a record of it. Once we
3205 find out if this thing needs dynamic relocation we'll
3206 expand the relocation sections by the appropriate amount. */
3208 struct alpha_elf_reloc_entry *rent;
3210 for (rent = h->reloc_entries; rent; rent = rent->next)
3211 if (rent->rtype == r_type && rent->srel == sreloc)
3216 amt = sizeof (struct alpha_elf_reloc_entry);
3217 rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
3221 rent->srel = sreloc;
3222 rent->rtype = r_type;
3224 rent->reltext = (sec->flags & SEC_READONLY) != 0;
3226 rent->next = h->reloc_entries;
3227 h->reloc_entries = rent;
3232 else if (info->shared)
3234 /* If this is a shared library, and the section is to be
3235 loaded into memory, we need a RELATIVE reloc. */
3236 sreloc->size += sizeof (Elf64_External_Rela);
3237 if (sec->flags & SEC_READONLY)
3238 info->flags |= DF_TEXTREL;
3246 /* Adjust a symbol defined by a dynamic object and referenced by a
3247 regular object. The current definition is in some section of the
3248 dynamic object, but we're not including those sections. We have to
3249 change the definition to something the rest of the link can
3253 elf64_alpha_adjust_dynamic_symbol (info, h)
3254 struct bfd_link_info *info;
3255 struct elf_link_hash_entry *h;
3259 struct alpha_elf_link_hash_entry *ah;
3261 dynobj = elf_hash_table(info)->dynobj;
3262 ah = (struct alpha_elf_link_hash_entry *)h;
3264 /* Now that we've seen all of the input symbols, finalize our decision
3265 about whether this symbol should get a .plt entry. */
3267 if (alpha_elf_dynamic_symbol_p (h, info)
3268 && ((h->type == STT_FUNC
3269 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
3270 || (h->type == STT_NOTYPE
3271 && (ah->flags & ALPHA_ELF_LINK_HASH_LU_FUNC)
3272 && !(ah->flags & ~ALPHA_ELF_LINK_HASH_LU_FUNC)))
3273 /* Don't prevent otherwise valid programs from linking by attempting
3274 to create a new .got entry somewhere. A Correct Solution would be
3275 to add a new .got section to a new object file and let it be merged
3276 somewhere later. But for now don't bother. */
3281 s = bfd_get_section_by_name(dynobj, ".plt");
3282 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
3285 /* The first bit of the .plt is reserved. */
3287 s->size = PLT_HEADER_SIZE;
3289 h->plt.offset = s->size;
3290 s->size += PLT_ENTRY_SIZE;
3292 /* If this symbol is not defined in a regular file, and we are not
3293 generating a shared library, then set the symbol to the location
3294 in the .plt. This is required to make function pointers compare
3295 equal between the normal executable and the shared library. */
3297 && h->root.type != bfd_link_hash_defweak)
3299 ah->plt_old_section = h->root.u.def.section;
3300 ah->plt_old_value = h->root.u.def.value;
3301 ah->flags |= ALPHA_ELF_LINK_HASH_PLT_LOC;
3302 h->root.u.def.section = s;
3303 h->root.u.def.value = h->plt.offset;
3306 /* We also need a JMP_SLOT entry in the .rela.plt section. */
3307 s = bfd_get_section_by_name (dynobj, ".rela.plt");
3308 BFD_ASSERT (s != NULL);
3309 s->size += sizeof (Elf64_External_Rela);
3316 /* If this is a weak symbol, and there is a real definition, the
3317 processor independent code will have arranged for us to see the
3318 real definition first, and we can just use the same value. */
3319 if (h->u.weakdef != NULL)
3321 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3322 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3323 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3324 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3328 /* This is a reference to a symbol defined by a dynamic object which
3329 is not a function. The Alpha, since it uses .got entries for all
3330 symbols even in regular objects, does not need the hackery of a
3331 .dynbss section and COPY dynamic relocations. */
3336 /* Symbol versioning can create new symbols, and make our old symbols
3337 indirect to the new ones. Consolidate the got and reloc information
3338 in these situations. */
3341 elf64_alpha_merge_ind_symbols (hi, dummy)
3342 struct alpha_elf_link_hash_entry *hi;
3343 PTR dummy ATTRIBUTE_UNUSED;
3345 struct alpha_elf_link_hash_entry *hs;
3347 if (hi->root.root.type != bfd_link_hash_indirect)
3351 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
3352 } while (hs->root.root.type == bfd_link_hash_indirect);
3354 /* Merge the flags. Whee. */
3356 hs->flags |= hi->flags;
3358 /* Merge the .got entries. Cannibalize the old symbol's list in
3359 doing so, since we don't need it anymore. */
3361 if (hs->got_entries == NULL)
3362 hs->got_entries = hi->got_entries;
3365 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
3367 gsh = hs->got_entries;
3368 for (gi = hi->got_entries; gi ; gi = gin)
3371 for (gs = gsh; gs ; gs = gs->next)
3372 if (gi->gotobj == gs->gotobj
3373 && gi->reloc_type == gs->reloc_type
3374 && gi->addend == gs->addend)
3376 gi->use_count += gs->use_count;
3379 gi->next = hs->got_entries;
3380 hs->got_entries = gi;
3384 hi->got_entries = NULL;
3386 /* And similar for the reloc entries. */
3388 if (hs->reloc_entries == NULL)
3389 hs->reloc_entries = hi->reloc_entries;
3392 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
3394 rsh = hs->reloc_entries;
3395 for (ri = hi->reloc_entries; ri ; ri = rin)
3398 for (rs = rsh; rs ; rs = rs->next)
3399 if (ri->rtype == rs->rtype && ri->srel == rs->srel)
3401 rs->count += ri->count;
3404 ri->next = hs->reloc_entries;
3405 hs->reloc_entries = ri;
3409 hi->reloc_entries = NULL;
3414 /* Is it possible to merge two object file's .got tables? */
3417 elf64_alpha_can_merge_gots (a, b)
3420 int total = alpha_elf_tdata (a)->total_got_size;
3423 /* Trivial quick fallout test. */
3424 if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
3427 /* By their nature, local .got entries cannot be merged. */
3428 if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
3431 /* Failing the common trivial comparison, we must effectively
3432 perform the merge. Not actually performing the merge means that
3433 we don't have to store undo information in case we fail. */
3434 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3436 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
3437 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3440 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
3441 for (i = 0; i < n; ++i)
3443 struct alpha_elf_got_entry *ae, *be;
3444 struct alpha_elf_link_hash_entry *h;
3447 while (h->root.root.type == bfd_link_hash_indirect
3448 || h->root.root.type == bfd_link_hash_warning)
3449 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3451 for (be = h->got_entries; be ; be = be->next)
3453 if (be->use_count == 0)
3455 if (be->gotobj != b)
3458 for (ae = h->got_entries; ae ; ae = ae->next)
3460 && ae->reloc_type == be->reloc_type
3461 && ae->addend == be->addend)
3464 total += alpha_got_entry_size (be->reloc_type);
3465 if (total > MAX_GOT_SIZE)
3475 /* Actually merge two .got tables. */
3478 elf64_alpha_merge_gots (a, b)
3481 int total = alpha_elf_tdata (a)->total_got_size;
3484 /* Remember local expansion. */
3486 int e = alpha_elf_tdata (b)->local_got_size;
3488 alpha_elf_tdata (a)->local_got_size += e;
3491 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
3493 struct alpha_elf_got_entry **local_got_entries;
3494 struct alpha_elf_link_hash_entry **hashes;
3495 Elf_Internal_Shdr *symtab_hdr;
3498 /* Let the local .got entries know they are part of a new subsegment. */
3499 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
3500 if (local_got_entries)
3502 n = elf_tdata (bsub)->symtab_hdr.sh_info;
3503 for (i = 0; i < n; ++i)
3505 struct alpha_elf_got_entry *ent;
3506 for (ent = local_got_entries[i]; ent; ent = ent->next)
3511 /* Merge the global .got entries. */
3512 hashes = alpha_elf_sym_hashes (bsub);
3513 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
3515 n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
3516 for (i = 0; i < n; ++i)
3518 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
3519 struct alpha_elf_link_hash_entry *h;
3522 while (h->root.root.type == bfd_link_hash_indirect
3523 || h->root.root.type == bfd_link_hash_warning)
3524 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3526 start = &h->got_entries;
3527 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
3529 if (be->use_count == 0)
3534 if (be->gotobj != b)
3537 for (ae = *start; ae ; ae = ae->next)
3539 && ae->reloc_type == be->reloc_type
3540 && ae->addend == be->addend)
3542 ae->flags |= be->flags;
3543 ae->use_count += be->use_count;
3548 total += alpha_got_entry_size (be->reloc_type);
3554 alpha_elf_tdata (bsub)->gotobj = a;
3556 alpha_elf_tdata (a)->total_got_size = total;
3558 /* Merge the two in_got chains. */
3563 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
3566 alpha_elf_tdata (bsub)->in_got_link_next = b;
3570 /* Calculate the offsets for the got entries. */
3573 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
3574 struct alpha_elf_link_hash_entry *h;
3575 PTR arg ATTRIBUTE_UNUSED;
3577 bfd_boolean result = TRUE;
3578 struct alpha_elf_got_entry *gotent;
3580 if (h->root.root.type == bfd_link_hash_warning)
3581 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3583 for (gotent = h->got_entries; gotent; gotent = gotent->next)
3584 if (gotent->use_count > 0)
3586 struct alpha_elf_obj_tdata *td;
3587 bfd_size_type *plge;
3589 td = alpha_elf_tdata (gotent->gotobj);
3592 _bfd_error_handler (_("Symbol %s has no GOT subsection for offset 0x%x"),
3593 h->root.root.root.string, gotent->got_offset);
3597 plge = &td->got->size;
3598 gotent->got_offset = *plge;
3599 *plge += alpha_got_entry_size (gotent->reloc_type);
3606 elf64_alpha_calc_got_offsets (info)
3607 struct bfd_link_info *info;
3609 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
3611 /* First, zero out the .got sizes, as we may be recalculating the
3612 .got after optimizing it. */
3613 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3614 alpha_elf_tdata(i)->got->size = 0;
3616 /* Next, fill in the offsets for all the global entries. */
3617 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3618 elf64_alpha_calc_got_offsets_for_symbol,
3621 /* Finally, fill in the offsets for the local entries. */
3622 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
3624 bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
3627 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3629 struct alpha_elf_got_entry **local_got_entries, *gotent;
3632 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3633 if (!local_got_entries)
3636 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3637 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
3638 if (gotent->use_count > 0)
3640 gotent->got_offset = got_offset;
3641 got_offset += alpha_got_entry_size (gotent->reloc_type);
3645 alpha_elf_tdata(i)->got->size = got_offset;
3649 /* Constructs the gots. */
3652 elf64_alpha_size_got_sections (info)
3653 struct bfd_link_info *info;
3655 bfd *i, *got_list, *cur_got_obj = NULL;
3656 int something_changed = 0;
3658 got_list = alpha_elf_hash_table (info)->got_list;
3660 /* On the first time through, pretend we have an existing got list
3661 consisting of all of the input files. */
3662 if (got_list == NULL)
3664 for (i = info->input_bfds; i ; i = i->link_next)
3666 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3667 if (this_got == NULL)
3670 /* We are assuming no merging has yet occurred. */
3671 BFD_ASSERT (this_got == i);
3673 if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
3675 /* Yikes! A single object file has too many entries. */
3676 (*_bfd_error_handler)
3677 (_("%B: .got subsegment exceeds 64K (size %d)"),
3678 i, alpha_elf_tdata (this_got)->total_got_size);
3682 if (got_list == NULL)
3683 got_list = this_got;
3685 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3686 cur_got_obj = this_got;
3689 /* Strange degenerate case of no got references. */
3690 if (got_list == NULL)
3693 alpha_elf_hash_table (info)->got_list = got_list;
3695 /* Force got offsets to be recalculated. */
3696 something_changed = 1;
3699 cur_got_obj = got_list;
3700 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3703 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3705 elf64_alpha_merge_gots (cur_got_obj, i);
3706 i = alpha_elf_tdata(i)->got_link_next;
3707 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3708 something_changed = 1;
3713 i = alpha_elf_tdata(i)->got_link_next;
3717 /* Once the gots have been merged, fill in the got offsets for
3718 everything therein. */
3719 if (1 || something_changed)
3720 elf64_alpha_calc_got_offsets (info);
3725 /* Called from relax_section to rebuild the PLT in light of
3726 potential changes in the function's status. */
3729 elf64_alpha_size_plt_section (info)
3730 struct bfd_link_info *info;
3732 asection *splt, *spltrel;
3733 unsigned long entries;
3736 dynobj = elf_hash_table(info)->dynobj;
3737 splt = bfd_get_section_by_name(dynobj, ".plt");
3743 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3744 elf64_alpha_size_plt_section_1, splt);
3746 /* Every plt entry requires a JMP_SLOT relocation. */
3747 spltrel = bfd_get_section_by_name (dynobj, ".rela.plt");
3749 entries = (splt->size - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3752 spltrel->size = entries * sizeof (Elf64_External_Rela);
3758 elf64_alpha_size_plt_section_1 (h, data)
3759 struct alpha_elf_link_hash_entry *h;
3762 asection *splt = (asection *) data;
3763 struct alpha_elf_got_entry *gotent;
3765 /* If we didn't need an entry before, we still don't. */
3766 if (!h->root.needs_plt)
3769 /* There must still be a LITERAL got entry for the function. */
3770 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3771 if (gotent->reloc_type == R_ALPHA_LITERAL
3772 && gotent->use_count > 0)
3775 /* If there is, reset the PLT offset. If not, there's no longer
3776 a need for the PLT entry. */
3779 if (splt->size == 0)
3780 splt->size = PLT_HEADER_SIZE;
3781 h->root.plt.offset = splt->size;
3782 splt->size += PLT_ENTRY_SIZE;
3786 h->root.needs_plt = 0;
3787 h->root.plt.offset = -1;
3789 /* Undo the definition frobbing begun in adjust_dynamic_symbol. */
3790 if (h->flags & ALPHA_ELF_LINK_HASH_PLT_LOC)
3792 h->root.root.u.def.section = h->plt_old_section;
3793 h->root.root.u.def.value = h->plt_old_value;
3794 h->flags &= ~ALPHA_ELF_LINK_HASH_PLT_LOC;
3802 elf64_alpha_always_size_sections (output_bfd, info)
3803 bfd *output_bfd ATTRIBUTE_UNUSED;
3804 struct bfd_link_info *info;
3808 if (info->relocatable)
3811 /* First, take care of the indirect symbols created by versioning. */
3812 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3813 elf64_alpha_merge_ind_symbols,
3816 if (!elf64_alpha_size_got_sections (info))
3819 /* Allocate space for all of the .got subsections. */
3820 i = alpha_elf_hash_table (info)->got_list;
3821 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3823 asection *s = alpha_elf_tdata(i)->got;
3826 s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
3827 if (s->contents == NULL)
3835 /* The number of dynamic relocations required by a static relocation. */
3838 alpha_dynamic_entries_for_reloc (r_type, dynamic, shared)
3839 int r_type, dynamic, shared;
3843 /* May appear in GOT entries. */
3845 return (dynamic ? 2 : shared ? 1 : 0);
3846 case R_ALPHA_TLSLDM:
3848 case R_ALPHA_LITERAL:
3849 case R_ALPHA_GOTTPREL:
3850 return dynamic || shared;
3851 case R_ALPHA_GOTDTPREL:
3854 /* May appear in data sections. */
3855 case R_ALPHA_REFLONG:
3856 case R_ALPHA_REFQUAD:
3857 case R_ALPHA_TPREL64:
3858 return dynamic || shared;
3860 /* Everything else is illegal. We'll issue an error during
3861 relocate_section. */
3867 /* Work out the sizes of the dynamic relocation entries. */
3870 elf64_alpha_calc_dynrel_sizes (h, info)
3871 struct alpha_elf_link_hash_entry *h;
3872 struct bfd_link_info *info;
3874 bfd_boolean dynamic;
3875 struct alpha_elf_reloc_entry *relent;
3876 unsigned long entries;
3878 if (h->root.root.type == bfd_link_hash_warning)
3879 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3881 /* If the symbol was defined as a common symbol in a regular object
3882 file, and there was no definition in any dynamic object, then the
3883 linker will have allocated space for the symbol in a common
3884 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3885 set. This is done for dynamic symbols in
3886 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3887 symbols, somehow. */
3888 if (!h->root.def_regular
3889 && h->root.ref_regular
3890 && !h->root.def_dynamic
3891 && (h->root.root.type == bfd_link_hash_defined
3892 || h->root.root.type == bfd_link_hash_defweak)
3893 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3894 h->root.def_regular = 1;
3896 /* If the symbol is dynamic, we'll need all the relocations in their
3897 natural form. If this is a shared object, and it has been forced
3898 local, we'll need the same number of RELATIVE relocations. */
3899 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
3901 /* If the symbol is a hidden undefined weak, then we never have any
3902 relocations. Avoid the loop which may want to add RELATIVE relocs
3903 based on info->shared. */
3904 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
3907 for (relent = h->reloc_entries; relent; relent = relent->next)
3909 entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
3913 relent->srel->size +=
3914 entries * sizeof (Elf64_External_Rela) * relent->count;
3915 if (relent->reltext)
3916 info->flags |= DT_TEXTREL;
3923 /* Set the sizes of the dynamic relocation sections. */
3926 elf64_alpha_size_rela_got_section (info)
3927 struct bfd_link_info *info;
3929 unsigned long entries;
3933 /* Shared libraries often require RELATIVE relocs, and some relocs
3934 require attention for the main application as well. */
3937 for (i = alpha_elf_hash_table(info)->got_list;
3938 i ; i = alpha_elf_tdata(i)->got_link_next)
3942 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
3944 struct alpha_elf_got_entry **local_got_entries, *gotent;
3947 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
3948 if (!local_got_entries)
3951 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
3952 for (gotent = local_got_entries[k];
3953 gotent ; gotent = gotent->next)
3954 if (gotent->use_count > 0)
3955 entries += (alpha_dynamic_entries_for_reloc
3956 (gotent->reloc_type, 0, info->shared));
3960 dynobj = elf_hash_table(info)->dynobj;
3961 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3964 BFD_ASSERT (entries == 0);
3967 srel->size = sizeof (Elf64_External_Rela) * entries;
3969 /* Now do the non-local symbols. */
3970 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3971 elf64_alpha_size_rela_got_1, info);
3976 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
3980 elf64_alpha_size_rela_got_1 (h, info)
3981 struct alpha_elf_link_hash_entry *h;
3982 struct bfd_link_info *info;
3984 bfd_boolean dynamic;
3985 struct alpha_elf_got_entry *gotent;
3986 unsigned long entries;
3988 if (h->root.root.type == bfd_link_hash_warning)
3989 h = (struct alpha_elf_link_hash_entry *) h->root.root.u.i.link;
3991 /* If the symbol is dynamic, we'll need all the relocations in their
3992 natural form. If this is a shared object, and it has been forced
3993 local, we'll need the same number of RELATIVE relocations. */
3994 dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
3996 /* If the symbol is a hidden undefined weak, then we never have any
3997 relocations. Avoid the loop which may want to add RELATIVE relocs
3998 based on info->shared. */
3999 if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
4003 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
4004 if (gotent->use_count > 0)
4005 entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type,
4006 dynamic, info->shared);
4008 /* If we are using a .plt entry, subtract one, as the first
4009 reference uses a .rela.plt entry instead. */
4010 if (h->root.plt.offset != MINUS_ONE)
4015 bfd *dynobj = elf_hash_table(info)->dynobj;
4016 asection *srel = bfd_get_section_by_name (dynobj, ".rela.got");
4017 BFD_ASSERT (srel != NULL);
4018 srel->size += sizeof (Elf64_External_Rela) * entries;
4024 /* Set the sizes of the dynamic sections. */
4027 elf64_alpha_size_dynamic_sections (output_bfd, info)
4028 bfd *output_bfd ATTRIBUTE_UNUSED;
4029 struct bfd_link_info *info;
4035 dynobj = elf_hash_table(info)->dynobj;
4036 BFD_ASSERT(dynobj != NULL);
4038 if (elf_hash_table (info)->dynamic_sections_created)
4040 /* Set the contents of the .interp section to the interpreter. */
4041 if (info->executable)
4043 s = bfd_get_section_by_name (dynobj, ".interp");
4044 BFD_ASSERT (s != NULL);
4045 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4046 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4049 /* Now that we've seen all of the input files, we can decide which
4050 symbols need dynamic relocation entries and which don't. We've
4051 collected information in check_relocs that we can now apply to
4052 size the dynamic relocation sections. */
4053 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
4054 elf64_alpha_calc_dynrel_sizes, info);
4056 elf64_alpha_size_rela_got_section (info);
4058 /* else we're not dynamic and by definition we don't need such things. */
4060 /* The check_relocs and adjust_dynamic_symbol entry points have
4061 determined the sizes of the various dynamic sections. Allocate
4064 for (s = dynobj->sections; s != NULL; s = s->next)
4069 if (!(s->flags & SEC_LINKER_CREATED))
4072 /* It's OK to base decisions on the section name, because none
4073 of the dynobj section names depend upon the input files. */
4074 name = bfd_get_section_name (dynobj, s);
4076 /* If we don't need this section, strip it from the output file.
4077 This is to handle .rela.bss and .rela.plt. We must create it
4078 in create_dynamic_sections, because it must be created before
4079 the linker maps input sections to output sections. The
4080 linker does that before adjust_dynamic_symbol is called, and
4081 it is that function which decides whether anything needs to
4082 go into these sections. */
4086 if (strncmp (name, ".rela", 5) == 0)
4088 strip = (s->size == 0);
4092 if (strcmp(name, ".rela.plt") == 0)
4095 /* We use the reloc_count field as a counter if we need
4096 to copy relocs into the output file. */
4100 else if (strcmp (name, ".plt") != 0)
4102 /* It's not one of our dynamic sections, so don't allocate space. */
4107 s->flags |= SEC_EXCLUDE;
4110 /* Allocate memory for the section contents. */
4111 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4112 if (s->contents == NULL && s->size != 0)
4117 if (elf_hash_table (info)->dynamic_sections_created)
4119 /* Add some entries to the .dynamic section. We fill in the
4120 values later, in elf64_alpha_finish_dynamic_sections, but we
4121 must add the entries now so that we get the correct size for
4122 the .dynamic section. The DT_DEBUG entry is filled in by the
4123 dynamic linker and used by the debugger. */
4124 #define add_dynamic_entry(TAG, VAL) \
4125 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4127 if (info->executable)
4129 if (!add_dynamic_entry (DT_DEBUG, 0))
4135 if (!add_dynamic_entry (DT_PLTGOT, 0)
4136 || !add_dynamic_entry (DT_PLTRELSZ, 0)
4137 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4138 || !add_dynamic_entry (DT_JMPREL, 0))
4142 if (!add_dynamic_entry (DT_RELA, 0)
4143 || !add_dynamic_entry (DT_RELASZ, 0)
4144 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
4147 if (info->flags & DF_TEXTREL)
4149 if (!add_dynamic_entry (DT_TEXTREL, 0))
4153 #undef add_dynamic_entry
4158 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4159 into the next available slot in SREL. */
4162 elf64_alpha_emit_dynrel (abfd, info, sec, srel, offset, dynindx, rtype, addend)
4164 struct bfd_link_info *info;
4165 asection *sec, *srel;
4166 bfd_vma offset, addend;
4167 long dynindx, rtype;
4169 Elf_Internal_Rela outrel;
4172 BFD_ASSERT (srel != NULL);
4174 outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4175 outrel.r_addend = addend;
4177 offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4178 if ((offset | 1) != (bfd_vma) -1)
4179 outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4181 memset (&outrel, 0, sizeof (outrel));
4183 loc = srel->contents;
4184 loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4185 bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4186 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4189 /* Relocate an Alpha ELF section for a relocatable link.
4191 We don't have to change anything unless the reloc is against a section
4192 symbol, in which case we have to adjust according to where the section
4193 symbol winds up in the output section. */
4196 elf64_alpha_relocate_section_r (output_bfd, info, input_bfd, input_section,
4197 contents, relocs, local_syms, local_sections)
4198 bfd *output_bfd ATTRIBUTE_UNUSED;
4199 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4201 asection *input_section;
4202 bfd_byte *contents ATTRIBUTE_UNUSED;
4203 Elf_Internal_Rela *relocs;
4204 Elf_Internal_Sym *local_syms;
4205 asection **local_sections;
4207 unsigned long symtab_hdr_sh_info;
4208 Elf_Internal_Rela *rel;
4209 Elf_Internal_Rela *relend;
4210 bfd_boolean ret_val = TRUE;
4212 symtab_hdr_sh_info = elf_tdata (input_bfd)->symtab_hdr.sh_info;
4214 relend = relocs + input_section->reloc_count;
4215 for (rel = relocs; rel < relend; rel++)
4217 unsigned long r_symndx;
4218 Elf_Internal_Sym *sym;
4220 unsigned long r_type;
4222 r_type = ELF64_R_TYPE(rel->r_info);
4223 if (r_type >= R_ALPHA_max)
4225 (*_bfd_error_handler)
4226 (_("%B: unknown relocation type %d"),
4227 input_bfd, (int) r_type);
4228 bfd_set_error (bfd_error_bad_value);
4233 r_symndx = ELF64_R_SYM(rel->r_info);
4235 /* The symbol associated with GPDISP and LITUSE is
4236 immaterial. Only the addend is significant. */
4237 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4240 if (r_symndx < symtab_hdr_sh_info)
4242 sym = local_syms + r_symndx;
4243 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
4245 sec = local_sections[r_symndx];
4246 rel->r_addend += sec->output_offset + sym->st_value;
4254 /* Relocate an Alpha ELF section. */
4257 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
4258 contents, relocs, local_syms, local_sections)
4260 struct bfd_link_info *info;
4262 asection *input_section;
4264 Elf_Internal_Rela *relocs;
4265 Elf_Internal_Sym *local_syms;
4266 asection **local_sections;
4268 Elf_Internal_Shdr *symtab_hdr;
4269 Elf_Internal_Rela *rel;
4270 Elf_Internal_Rela *relend;
4271 asection *sgot, *srel, *srelgot;
4272 bfd *dynobj, *gotobj;
4273 bfd_vma gp, tp_base, dtp_base;
4274 struct alpha_elf_got_entry **local_got_entries;
4275 bfd_boolean ret_val;
4277 /* Handle relocatable links with a smaller loop. */
4278 if (info->relocatable)
4279 return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4280 input_section, contents, relocs,
4281 local_syms, local_sections);
4283 /* This is a final link. */
4287 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4289 dynobj = elf_hash_table (info)->dynobj;
4291 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
4295 if (input_section->flags & SEC_ALLOC)
4297 const char *section_name;
4298 section_name = (bfd_elf_string_from_elf_section
4299 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4300 elf_section_data(input_section)->rel_hdr.sh_name));
4301 BFD_ASSERT(section_name != NULL);
4302 srel = bfd_get_section_by_name (dynobj, section_name);
4307 /* Find the gp value for this input bfd. */
4308 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4311 sgot = alpha_elf_tdata (gotobj)->got;
4312 gp = _bfd_get_gp_value (gotobj);
4315 gp = (sgot->output_section->vma
4316 + sgot->output_offset
4318 _bfd_set_gp_value (gotobj, gp);
4327 local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4329 if (elf_hash_table (info)->tls_sec != NULL)
4331 dtp_base = alpha_get_dtprel_base (info);
4332 tp_base = alpha_get_tprel_base (info);
4335 dtp_base = tp_base = 0;
4337 relend = relocs + input_section->reloc_count;
4338 for (rel = relocs; rel < relend; rel++)
4340 struct alpha_elf_link_hash_entry *h = NULL;
4341 struct alpha_elf_got_entry *gotent;
4342 bfd_reloc_status_type r;
4343 reloc_howto_type *howto;
4344 unsigned long r_symndx;
4345 Elf_Internal_Sym *sym = NULL;
4346 asection *sec = NULL;
4349 bfd_boolean dynamic_symbol_p;
4350 bfd_boolean undef_weak_ref = FALSE;
4351 unsigned long r_type;
4353 r_type = ELF64_R_TYPE(rel->r_info);
4354 if (r_type >= R_ALPHA_max)
4356 (*_bfd_error_handler)
4357 (_("%B: unknown relocation type %d"),
4358 input_bfd, (int) r_type);
4359 bfd_set_error (bfd_error_bad_value);
4364 howto = elf64_alpha_howto_table + r_type;
4365 r_symndx = ELF64_R_SYM(rel->r_info);
4367 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4368 reloc to the 0 symbol so that they all match. */
4369 if (r_type == R_ALPHA_TLSLDM)
4372 if (r_symndx < symtab_hdr->sh_info)
4375 sym = local_syms + r_symndx;
4376 sec = local_sections[r_symndx];
4378 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4380 /* If this is a tp-relative relocation against sym 0,
4381 this is hackery from relax_section. Force the value to
4384 && (r_type == R_ALPHA_TLSLDM
4385 || r_type == R_ALPHA_GOTTPREL
4386 || r_type == R_ALPHA_TPREL64
4387 || r_type == R_ALPHA_TPRELHI
4388 || r_type == R_ALPHA_TPRELLO
4389 || r_type == R_ALPHA_TPREL16))
4392 if (local_got_entries)
4393 gotent = local_got_entries[r_symndx];
4397 /* Need to adjust local GOT entries' addends for SEC_MERGE
4398 unless it has been done already. */
4399 if ((sec->flags & SEC_MERGE)
4400 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4401 && sec->sec_info_type == ELF_INFO_TYPE_MERGE
4403 && !gotent->reloc_xlated)
4405 struct alpha_elf_got_entry *ent;
4407 for (ent = gotent; ent; ent = ent->next)
4409 ent->reloc_xlated = 1;
4410 if (ent->use_count == 0)
4414 _bfd_merged_section_offset (output_bfd, &msec,
4415 elf_section_data (sec)->
4417 sym->st_value + ent->addend);
4418 ent->addend -= sym->st_value;
4419 ent->addend += msec->output_section->vma
4420 + msec->output_offset
4421 - sec->output_section->vma
4422 - sec->output_offset;
4426 dynamic_symbol_p = FALSE;
4431 bfd_boolean unresolved_reloc;
4432 struct elf_link_hash_entry *hh;
4433 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4435 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4436 r_symndx, symtab_hdr, sym_hashes,
4438 unresolved_reloc, warned);
4444 && ! unresolved_reloc
4445 && hh->root.type == bfd_link_hash_undefweak)
4446 undef_weak_ref = TRUE;
4448 h = (struct alpha_elf_link_hash_entry *) hh;
4449 dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4450 gotent = h->got_entries;
4453 addend = rel->r_addend;
4456 /* Search for the proper got entry. */
4457 for (; gotent ; gotent = gotent->next)
4458 if (gotent->gotobj == gotobj
4459 && gotent->reloc_type == r_type
4460 && gotent->addend == addend)
4465 case R_ALPHA_GPDISP:
4467 bfd_byte *p_ldah, *p_lda;
4469 BFD_ASSERT(gp != 0);
4471 value = (input_section->output_section->vma
4472 + input_section->output_offset
4475 p_ldah = contents + rel->r_offset;
4476 p_lda = p_ldah + rel->r_addend;
4478 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4483 case R_ALPHA_LITERAL:
4484 BFD_ASSERT(sgot != NULL);
4485 BFD_ASSERT(gp != 0);
4486 BFD_ASSERT(gotent != NULL);
4487 BFD_ASSERT(gotent->use_count >= 1);
4489 if (!gotent->reloc_done)
4491 gotent->reloc_done = 1;
4493 bfd_put_64 (output_bfd, value,
4494 sgot->contents + gotent->got_offset);
4496 /* If the symbol has been forced local, output a
4497 RELATIVE reloc, otherwise it will be handled in
4498 finish_dynamic_symbol. */
4499 if (info->shared && !dynamic_symbol_p && !undef_weak_ref)
4500 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4501 gotent->got_offset, 0,
4502 R_ALPHA_RELATIVE, value);
4505 value = (sgot->output_section->vma
4506 + sgot->output_offset
4507 + gotent->got_offset);
4511 case R_ALPHA_GPREL32:
4512 /* If the target section was a removed linkonce section,
4513 r_symndx will be zero. In this case, assume that the
4514 switch will not be used, so don't fill it in. If we
4515 do nothing here, we'll get relocation truncated messages,
4516 due to the placement of the application above 4GB. */
4524 case R_ALPHA_GPREL16:
4525 case R_ALPHA_GPRELLOW:
4526 if (dynamic_symbol_p)
4528 (*_bfd_error_handler)
4529 (_("%B: gp-relative relocation against dynamic symbol %s"),
4530 input_bfd, h->root.root.root.string);
4533 BFD_ASSERT(gp != 0);
4537 case R_ALPHA_GPRELHIGH:
4538 if (dynamic_symbol_p)
4540 (*_bfd_error_handler)
4541 (_("%B: gp-relative relocation against dynamic symbol %s"),
4542 input_bfd, h->root.root.root.string);
4545 BFD_ASSERT(gp != 0);
4547 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4551 /* A call to a dynamic symbol is definitely out of range of
4552 the 16-bit displacement. Don't bother writing anything. */
4553 if (dynamic_symbol_p)
4558 /* The regular PC-relative stuff measures from the start of
4559 the instruction rather than the end. */
4563 case R_ALPHA_BRADDR:
4564 if (dynamic_symbol_p)
4566 (*_bfd_error_handler)
4567 (_("%B: pc-relative relocation against dynamic symbol %s"),
4568 input_bfd, h->root.root.root.string);
4571 /* The regular PC-relative stuff measures from the start of
4572 the instruction rather than the end. */
4581 /* The regular PC-relative stuff measures from the start of
4582 the instruction rather than the end. */
4585 /* The source and destination gp must be the same. Note that
4586 the source will always have an assigned gp, since we forced
4587 one in check_relocs, but that the destination may not, as
4588 it might not have had any relocations at all. Also take
4589 care not to crash if H is an undefined symbol. */
4590 if (h != NULL && sec != NULL
4591 && alpha_elf_tdata (sec->owner)->gotobj
4592 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4594 (*_bfd_error_handler)
4595 (_("%B: change in gp: BRSGP %s"),
4596 input_bfd, h->root.root.root.string);
4600 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4602 other = h->root.other;
4604 other = sym->st_other;
4605 switch (other & STO_ALPHA_STD_GPLOAD)
4607 case STO_ALPHA_NOPV:
4609 case STO_ALPHA_STD_GPLOAD:
4614 name = h->root.root.root.string;
4617 name = (bfd_elf_string_from_elf_section
4618 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4620 name = _("<unknown>");
4621 else if (name[0] == 0)
4622 name = bfd_section_name (input_bfd, sec);
4624 (*_bfd_error_handler)
4625 (_("%B: !samegp reloc against symbol without .prologue: %s"),
4634 case R_ALPHA_REFLONG:
4635 case R_ALPHA_REFQUAD:
4636 case R_ALPHA_DTPREL64:
4637 case R_ALPHA_TPREL64:
4639 long dynindx, dyntype = r_type;
4642 /* Careful here to remember RELATIVE relocations for global
4643 variables for symbolic shared objects. */
4645 if (dynamic_symbol_p)
4647 BFD_ASSERT(h->root.dynindx != -1);
4648 dynindx = h->root.dynindx;
4650 addend = 0, value = 0;
4652 else if (r_type == R_ALPHA_DTPREL64)
4654 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4658 else if (r_type == R_ALPHA_TPREL64)
4660 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4667 dynaddend = value - dtp_base;
4669 else if (info->shared
4671 && (input_section->flags & SEC_ALLOC)
4674 if (r_type == R_ALPHA_REFLONG)
4676 (*_bfd_error_handler)
4677 (_("%B: unhandled dynamic relocation against %s"),
4679 h->root.root.root.string);
4683 dyntype = R_ALPHA_RELATIVE;
4689 if (input_section->flags & SEC_ALLOC)
4690 elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4691 srel, rel->r_offset, dynindx,
4692 dyntype, dynaddend);
4696 case R_ALPHA_SREL16:
4697 case R_ALPHA_SREL32:
4698 case R_ALPHA_SREL64:
4699 if (dynamic_symbol_p)
4701 (*_bfd_error_handler)
4702 (_("%B: pc-relative relocation against dynamic symbol %s"),
4703 input_bfd, h->root.root.root.string);
4706 else if ((info->shared || info->pie) && undef_weak_ref)
4708 (*_bfd_error_handler)
4709 (_("%B: pc-relative relocation against undefined weak symbol %s"),
4710 input_bfd, h->root.root.root.string);
4715 /* ??? .eh_frame references to discarded sections will be smashed
4716 to relocations against SHN_UNDEF. The .eh_frame format allows
4717 NULL to be encoded as 0 in any format, so this works here. */
4719 howto = (elf64_alpha_howto_table
4720 + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4723 case R_ALPHA_TLSLDM:
4724 /* Ignore the symbol for the relocation. The result is always
4725 the current module. */
4726 dynamic_symbol_p = 0;
4730 if (!gotent->reloc_done)
4732 gotent->reloc_done = 1;
4734 /* Note that the module index for the main program is 1. */
4735 bfd_put_64 (output_bfd, !info->shared && !dynamic_symbol_p,
4736 sgot->contents + gotent->got_offset);
4738 /* If the symbol has been forced local, output a
4739 DTPMOD64 reloc, otherwise it will be handled in
4740 finish_dynamic_symbol. */
4741 if (info->shared && !dynamic_symbol_p)
4742 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4743 gotent->got_offset, 0,
4744 R_ALPHA_DTPMOD64, 0);
4746 if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4750 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4753 bfd_put_64 (output_bfd, value,
4754 sgot->contents + gotent->got_offset + 8);
4757 value = (sgot->output_section->vma
4758 + sgot->output_offset
4759 + gotent->got_offset);
4763 case R_ALPHA_DTPRELHI:
4764 case R_ALPHA_DTPRELLO:
4765 case R_ALPHA_DTPREL16:
4766 if (dynamic_symbol_p)
4768 (*_bfd_error_handler)
4769 (_("%B: dtp-relative relocation against dynamic symbol %s"),
4770 input_bfd, h->root.root.root.string);
4773 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4775 if (r_type == R_ALPHA_DTPRELHI)
4776 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4779 case R_ALPHA_TPRELHI:
4780 case R_ALPHA_TPRELLO:
4781 case R_ALPHA_TPREL16:
4784 (*_bfd_error_handler)
4785 (_("%B: TLS local exec code cannot be linked into shared objects"),
4789 else if (dynamic_symbol_p)
4791 (*_bfd_error_handler)
4792 (_("%B: tp-relative relocation against dynamic symbol %s"),
4793 input_bfd, h->root.root.root.string);
4796 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4798 if (r_type == R_ALPHA_TPRELHI)
4799 value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4802 case R_ALPHA_GOTDTPREL:
4803 case R_ALPHA_GOTTPREL:
4804 BFD_ASSERT(sgot != NULL);
4805 BFD_ASSERT(gp != 0);
4806 BFD_ASSERT(gotent != NULL);
4807 BFD_ASSERT(gotent->use_count >= 1);
4809 if (!gotent->reloc_done)
4811 gotent->reloc_done = 1;
4813 if (dynamic_symbol_p)
4817 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4818 if (r_type == R_ALPHA_GOTDTPREL)
4820 else if (!info->shared)
4824 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4825 gotent->got_offset, 0,
4831 bfd_put_64 (output_bfd, value,
4832 sgot->contents + gotent->got_offset);
4835 value = (sgot->output_section->vma
4836 + sgot->output_offset
4837 + gotent->got_offset);
4843 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4844 contents, rel->r_offset, value, 0);
4853 case bfd_reloc_overflow:
4857 /* Don't warn if the overflow is due to pc relative reloc
4858 against discarded section. Section optimization code should
4861 if (r_symndx < symtab_hdr->sh_info
4862 && sec != NULL && howto->pc_relative
4863 && elf_discarded_section (sec))
4870 name = (bfd_elf_string_from_elf_section
4871 (input_bfd, symtab_hdr->sh_link, sym->st_name));
4875 name = bfd_section_name (input_bfd, sec);
4877 if (! ((*info->callbacks->reloc_overflow)
4878 (info, (h ? &h->root.root : NULL), name, howto->name,
4879 (bfd_vma) 0, input_bfd, input_section,
4886 case bfd_reloc_outofrange:
4894 /* Finish up dynamic symbol handling. We set the contents of various
4895 dynamic sections here. */
4898 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
4900 struct bfd_link_info *info;
4901 struct elf_link_hash_entry *h;
4902 Elf_Internal_Sym *sym;
4904 bfd *dynobj = elf_hash_table(info)->dynobj;
4906 if (h->plt.offset != MINUS_ONE)
4908 /* Fill in the .plt entry for this symbol. */
4909 asection *splt, *sgot, *srel;
4910 Elf_Internal_Rela outrel;
4912 bfd_vma got_addr, plt_addr;
4914 struct alpha_elf_got_entry *gotent;
4916 BFD_ASSERT (h->dynindx != -1);
4918 /* The first .got entry will be updated by the .plt with the
4919 address of the target function. */
4920 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4921 BFD_ASSERT (gotent && gotent->addend == 0);
4923 splt = bfd_get_section_by_name (dynobj, ".plt");
4924 BFD_ASSERT (splt != NULL);
4925 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4926 BFD_ASSERT (srel != NULL);
4927 sgot = alpha_elf_tdata (gotent->gotobj)->got;
4928 BFD_ASSERT (sgot != NULL);
4930 got_addr = (sgot->output_section->vma
4931 + sgot->output_offset
4932 + gotent->got_offset);
4933 plt_addr = (splt->output_section->vma
4934 + splt->output_offset
4937 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4939 /* Fill in the entry in the procedure linkage table. */
4941 bfd_vma insn1, insn2, insn3;
4943 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
4944 insn2 = PLT_ENTRY_WORD2;
4945 insn3 = PLT_ENTRY_WORD3;
4947 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
4948 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
4949 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
4952 /* Fill in the entry in the .rela.plt section. */
4953 outrel.r_offset = got_addr;
4954 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4955 outrel.r_addend = 0;
4957 loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4958 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4960 if (!h->def_regular)
4962 /* Mark the symbol as undefined, rather than as defined in the
4963 .plt section. Leave the value alone. */
4964 sym->st_shndx = SHN_UNDEF;
4967 /* Fill in the entries in the .got. */
4968 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
4970 /* Subsequent .got entries will continue to bounce through the .plt. */
4973 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4974 BFD_ASSERT (! info->shared || srel != NULL);
4976 gotent = gotent->next;
4979 sgot = alpha_elf_tdata(gotent->gotobj)->got;
4980 BFD_ASSERT(sgot != NULL);
4981 BFD_ASSERT(gotent->addend == 0);
4983 bfd_put_64 (output_bfd, plt_addr,
4984 sgot->contents + gotent->got_offset);
4987 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4988 gotent->got_offset, 0,
4989 R_ALPHA_RELATIVE, plt_addr);
4991 gotent = gotent->next;
4993 while (gotent != NULL);
4996 else if (alpha_elf_dynamic_symbol_p (h, info))
4998 /* Fill in the dynamic relocations for this symbol's .got entries. */
5000 struct alpha_elf_got_entry *gotent;
5002 srel = bfd_get_section_by_name (dynobj, ".rela.got");
5003 BFD_ASSERT (srel != NULL);
5005 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
5007 gotent = gotent->next)
5012 if (gotent->use_count == 0)
5015 sgot = alpha_elf_tdata (gotent->gotobj)->got;
5017 r_type = gotent->reloc_type;
5020 case R_ALPHA_LITERAL:
5021 r_type = R_ALPHA_GLOB_DAT;
5024 r_type = R_ALPHA_DTPMOD64;
5026 case R_ALPHA_GOTDTPREL:
5027 r_type = R_ALPHA_DTPREL64;
5029 case R_ALPHA_GOTTPREL:
5030 r_type = R_ALPHA_TPREL64;
5032 case R_ALPHA_TLSLDM:
5037 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
5038 gotent->got_offset, h->dynindx,
5039 r_type, gotent->addend);
5041 if (gotent->reloc_type == R_ALPHA_TLSGD)
5042 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
5043 gotent->got_offset + 8, h->dynindx,
5044 R_ALPHA_DTPREL64, gotent->addend);
5048 /* Mark some specially defined symbols as absolute. */
5049 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5050 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
5051 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
5052 sym->st_shndx = SHN_ABS;
5057 /* Finish up the dynamic sections. */
5060 elf64_alpha_finish_dynamic_sections (output_bfd, info)
5062 struct bfd_link_info *info;
5067 dynobj = elf_hash_table (info)->dynobj;
5068 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5070 if (elf_hash_table (info)->dynamic_sections_created)
5073 Elf64_External_Dyn *dyncon, *dynconend;
5075 splt = bfd_get_section_by_name (dynobj, ".plt");
5076 BFD_ASSERT (splt != NULL && sdyn != NULL);
5078 dyncon = (Elf64_External_Dyn *) sdyn->contents;
5079 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
5080 for (; dyncon < dynconend; dyncon++)
5082 Elf_Internal_Dyn dyn;
5086 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
5101 /* My interpretation of the TIS v1.1 ELF document indicates
5102 that RELASZ should not include JMPREL. This is not what
5103 the rest of the BFD does. It is, however, what the
5104 glibc ld.so wants. Do this fixup here until we found
5105 out who is right. */
5106 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
5108 dyn.d_un.d_val -= s->size;
5112 s = bfd_get_section_by_name (output_bfd, name);
5113 dyn.d_un.d_ptr = (s ? s->vma : 0);
5117 s = bfd_get_section_by_name (output_bfd, name);
5118 dyn.d_un.d_val = s->size;
5122 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5125 /* Initialize the PLT0 entry. */
5128 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
5129 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
5130 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
5131 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
5133 /* The next two words will be filled in by ld.so */
5134 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 16);
5135 bfd_put_64 (output_bfd, (bfd_vma) 0, splt->contents + 24);
5137 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5144 /* We need to use a special link routine to handle the .mdebug section.
5145 We need to merge all instances of these sections together, not write
5146 them all out sequentially. */
5149 elf64_alpha_final_link (abfd, info)
5151 struct bfd_link_info *info;
5154 struct bfd_link_order *p;
5155 asection *mdebug_sec;
5156 struct ecoff_debug_info debug;
5157 const struct ecoff_debug_swap *swap
5158 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5159 HDRR *symhdr = &debug.symbolic_header;
5160 PTR mdebug_handle = NULL;
5162 /* Go through the sections and collect the mdebug information. */
5164 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5166 if (strcmp (o->name, ".mdebug") == 0)
5168 struct extsym_info einfo;
5170 /* We have found the .mdebug section in the output file.
5171 Look through all the link_orders comprising it and merge
5172 the information together. */
5173 symhdr->magic = swap->sym_magic;
5174 /* FIXME: What should the version stamp be? */
5176 symhdr->ilineMax = 0;
5180 symhdr->isymMax = 0;
5181 symhdr->ioptMax = 0;
5182 symhdr->iauxMax = 0;
5184 symhdr->issExtMax = 0;
5187 symhdr->iextMax = 0;
5189 /* We accumulate the debugging information itself in the
5190 debug_info structure. */
5192 debug.external_dnr = NULL;
5193 debug.external_pdr = NULL;
5194 debug.external_sym = NULL;
5195 debug.external_opt = NULL;
5196 debug.external_aux = NULL;
5198 debug.ssext = debug.ssext_end = NULL;
5199 debug.external_fdr = NULL;
5200 debug.external_rfd = NULL;
5201 debug.external_ext = debug.external_ext_end = NULL;
5203 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5204 if (mdebug_handle == (PTR) NULL)
5213 static const char * const name[] =
5215 ".text", ".init", ".fini", ".data",
5216 ".rodata", ".sdata", ".sbss", ".bss"
5218 static const int sc[] = { scText, scInit, scFini, scData,
5219 scRData, scSData, scSBss, scBss };
5222 esym.cobol_main = 0;
5226 esym.asym.iss = issNil;
5227 esym.asym.st = stLocal;
5228 esym.asym.reserved = 0;
5229 esym.asym.index = indexNil;
5230 for (i = 0; i < 8; i++)
5232 esym.asym.sc = sc[i];
5233 s = bfd_get_section_by_name (abfd, name[i]);
5236 esym.asym.value = s->vma;
5237 last = s->vma + s->size;
5240 esym.asym.value = last;
5242 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5248 for (p = o->map_head.link_order;
5249 p != (struct bfd_link_order *) NULL;
5252 asection *input_section;
5254 const struct ecoff_debug_swap *input_swap;
5255 struct ecoff_debug_info input_debug;
5259 if (p->type != bfd_indirect_link_order)
5261 if (p->type == bfd_data_link_order)
5266 input_section = p->u.indirect.section;
5267 input_bfd = input_section->owner;
5269 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
5270 || (get_elf_backend_data (input_bfd)
5271 ->elf_backend_ecoff_debug_swap) == NULL)
5273 /* I don't know what a non ALPHA ELF bfd would be
5274 doing with a .mdebug section, but I don't really
5275 want to deal with it. */
5279 input_swap = (get_elf_backend_data (input_bfd)
5280 ->elf_backend_ecoff_debug_swap);
5282 BFD_ASSERT (p->size == input_section->size);
5284 /* The ECOFF linking code expects that we have already
5285 read in the debugging information and set up an
5286 ecoff_debug_info structure, so we do that now. */
5287 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5291 if (! (bfd_ecoff_debug_accumulate
5292 (mdebug_handle, abfd, &debug, swap, input_bfd,
5293 &input_debug, input_swap, info)))
5296 /* Loop through the external symbols. For each one with
5297 interesting information, try to find the symbol in
5298 the linker global hash table and save the information
5299 for the output external symbols. */
5300 eraw_src = input_debug.external_ext;
5301 eraw_end = (eraw_src
5302 + (input_debug.symbolic_header.iextMax
5303 * input_swap->external_ext_size));
5305 eraw_src < eraw_end;
5306 eraw_src += input_swap->external_ext_size)
5310 struct alpha_elf_link_hash_entry *h;
5312 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
5313 if (ext.asym.sc == scNil
5314 || ext.asym.sc == scUndefined
5315 || ext.asym.sc == scSUndefined)
5318 name = input_debug.ssext + ext.asym.iss;
5319 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
5320 name, FALSE, FALSE, TRUE);
5321 if (h == NULL || h->esym.ifd != -2)
5327 < input_debug.symbolic_header.ifdMax);
5328 ext.ifd = input_debug.ifdmap[ext.ifd];
5334 /* Free up the information we just read. */
5335 free (input_debug.line);
5336 free (input_debug.external_dnr);
5337 free (input_debug.external_pdr);
5338 free (input_debug.external_sym);
5339 free (input_debug.external_opt);
5340 free (input_debug.external_aux);
5341 free (input_debug.ss);
5342 free (input_debug.ssext);
5343 free (input_debug.external_fdr);
5344 free (input_debug.external_rfd);
5345 free (input_debug.external_ext);
5347 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5348 elf_link_input_bfd ignores this section. */
5349 input_section->flags &=~ SEC_HAS_CONTENTS;
5352 /* Build the external symbol information. */
5355 einfo.debug = &debug;
5357 einfo.failed = FALSE;
5358 elf_link_hash_traverse (elf_hash_table (info),
5359 elf64_alpha_output_extsym,
5364 /* Set the size of the .mdebug section. */
5365 o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5367 /* Skip this section later on (I don't think this currently
5368 matters, but someday it might). */
5369 o->map_head.link_order = (struct bfd_link_order *) NULL;
5375 /* Invoke the regular ELF backend linker to do all the work. */
5376 if (! bfd_elf_final_link (abfd, info))
5379 /* Now write out the computed sections. */
5381 /* The .got subsections... */
5383 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5384 for (i = alpha_elf_hash_table(info)->got_list;
5386 i = alpha_elf_tdata(i)->got_link_next)
5390 /* elf_bfd_final_link already did everything in dynobj. */
5394 sgot = alpha_elf_tdata(i)->got;
5395 if (! bfd_set_section_contents (abfd, sgot->output_section,
5397 (file_ptr) sgot->output_offset,
5403 if (mdebug_sec != (asection *) NULL)
5405 BFD_ASSERT (abfd->output_has_begun);
5406 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5408 mdebug_sec->filepos))
5411 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5417 static enum elf_reloc_type_class
5418 elf64_alpha_reloc_type_class (rela)
5419 const Elf_Internal_Rela *rela;
5421 switch ((int) ELF64_R_TYPE (rela->r_info))
5423 case R_ALPHA_RELATIVE:
5424 return reloc_class_relative;
5425 case R_ALPHA_JMP_SLOT:
5426 return reloc_class_plt;
5428 return reloc_class_copy;
5430 return reloc_class_normal;
5434 static struct bfd_elf_special_section const
5435 alpha_special_sections_s[]=
5437 { ".sdata", 6, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5438 { ".sbss", 5, -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5439 { NULL, 0, 0, 0, 0 }
5442 static struct bfd_elf_special_section const *
5443 elf64_alpha_special_sections[27] =
5463 alpha_special_sections_s, /* 's' */
5474 /* ECOFF swapping routines. These are used when dealing with the
5475 .mdebug section, which is in the ECOFF debugging format. Copied
5476 from elf32-mips.c. */
5477 static const struct ecoff_debug_swap
5478 elf64_alpha_ecoff_debug_swap =
5480 /* Symbol table magic number. */
5482 /* Alignment of debugging information. E.g., 4. */
5484 /* Sizes of external symbolic information. */
5485 sizeof (struct hdr_ext),
5486 sizeof (struct dnr_ext),
5487 sizeof (struct pdr_ext),
5488 sizeof (struct sym_ext),
5489 sizeof (struct opt_ext),
5490 sizeof (struct fdr_ext),
5491 sizeof (struct rfd_ext),
5492 sizeof (struct ext_ext),
5493 /* Functions to swap in external symbolic data. */
5502 _bfd_ecoff_swap_tir_in,
5503 _bfd_ecoff_swap_rndx_in,
5504 /* Functions to swap out external symbolic data. */
5513 _bfd_ecoff_swap_tir_out,
5514 _bfd_ecoff_swap_rndx_out,
5515 /* Function to read in symbolic data. */
5516 elf64_alpha_read_ecoff_info
5519 /* Use a non-standard hash bucket size of 8. */
5521 static const struct elf_size_info alpha_elf_size_info =
5523 sizeof (Elf64_External_Ehdr),
5524 sizeof (Elf64_External_Phdr),
5525 sizeof (Elf64_External_Shdr),
5526 sizeof (Elf64_External_Rel),
5527 sizeof (Elf64_External_Rela),
5528 sizeof (Elf64_External_Sym),
5529 sizeof (Elf64_External_Dyn),
5530 sizeof (Elf_External_Note),
5534 ELFCLASS64, EV_CURRENT,
5535 bfd_elf64_write_out_phdrs,
5536 bfd_elf64_write_shdrs_and_ehdr,
5537 bfd_elf64_write_relocs,
5538 bfd_elf64_swap_symbol_in,
5539 bfd_elf64_swap_symbol_out,
5540 bfd_elf64_slurp_reloc_table,
5541 bfd_elf64_slurp_symbol_table,
5542 bfd_elf64_swap_dyn_in,
5543 bfd_elf64_swap_dyn_out,
5544 bfd_elf64_swap_reloc_in,
5545 bfd_elf64_swap_reloc_out,
5546 bfd_elf64_swap_reloca_in,
5547 bfd_elf64_swap_reloca_out
5550 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
5551 #define TARGET_LITTLE_NAME "elf64-alpha"
5552 #define ELF_ARCH bfd_arch_alpha
5553 #define ELF_MACHINE_CODE EM_ALPHA
5554 #define ELF_MAXPAGESIZE 0x10000
5556 #define bfd_elf64_bfd_link_hash_table_create \
5557 elf64_alpha_bfd_link_hash_table_create
5559 #define bfd_elf64_bfd_reloc_type_lookup \
5560 elf64_alpha_bfd_reloc_type_lookup
5561 #define elf_info_to_howto \
5562 elf64_alpha_info_to_howto
5564 #define bfd_elf64_mkobject \
5565 elf64_alpha_mkobject
5566 #define elf_backend_object_p \
5567 elf64_alpha_object_p
5569 #define elf_backend_section_from_shdr \
5570 elf64_alpha_section_from_shdr
5571 #define elf_backend_section_flags \
5572 elf64_alpha_section_flags
5573 #define elf_backend_fake_sections \
5574 elf64_alpha_fake_sections
5576 #define bfd_elf64_bfd_is_local_label_name \
5577 elf64_alpha_is_local_label_name
5578 #define bfd_elf64_find_nearest_line \
5579 elf64_alpha_find_nearest_line
5580 #define bfd_elf64_bfd_relax_section \
5581 elf64_alpha_relax_section
5583 #define elf_backend_add_symbol_hook \
5584 elf64_alpha_add_symbol_hook
5585 #define elf_backend_check_relocs \
5586 elf64_alpha_check_relocs
5587 #define elf_backend_create_dynamic_sections \
5588 elf64_alpha_create_dynamic_sections
5589 #define elf_backend_adjust_dynamic_symbol \
5590 elf64_alpha_adjust_dynamic_symbol
5591 #define elf_backend_always_size_sections \
5592 elf64_alpha_always_size_sections
5593 #define elf_backend_size_dynamic_sections \
5594 elf64_alpha_size_dynamic_sections
5595 #define elf_backend_relocate_section \
5596 elf64_alpha_relocate_section
5597 #define elf_backend_finish_dynamic_symbol \
5598 elf64_alpha_finish_dynamic_symbol
5599 #define elf_backend_finish_dynamic_sections \
5600 elf64_alpha_finish_dynamic_sections
5601 #define bfd_elf64_bfd_final_link \
5602 elf64_alpha_final_link
5603 #define elf_backend_reloc_type_class \
5604 elf64_alpha_reloc_type_class
5606 #define elf_backend_ecoff_debug_swap \
5607 &elf64_alpha_ecoff_debug_swap
5609 #define elf_backend_size_info \
5612 #define elf_backend_special_sections \
5613 elf64_alpha_special_sections
5615 /* A few constants that determine how the .plt section is set up. */
5616 #define elf_backend_want_got_plt 0
5617 #define elf_backend_plt_readonly 0
5618 #define elf_backend_want_plt_sym 1
5619 #define elf_backend_got_header_size 0
5621 #include "elf64-target.h"
5623 /* FreeBSD support. */
5625 #undef TARGET_LITTLE_SYM
5626 #define TARGET_LITTLE_SYM bfd_elf64_alpha_freebsd_vec
5627 #undef TARGET_LITTLE_NAME
5628 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5630 /* The kernel recognizes executables as valid only if they carry a
5631 "FreeBSD" label in the ELF header. So we put this label on all
5632 executables and (for simplicity) also all other object files. */
5634 static void elf64_alpha_fbsd_post_process_headers
5635 PARAMS ((bfd *, struct bfd_link_info *));
5638 elf64_alpha_fbsd_post_process_headers (abfd, link_info)
5640 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
5642 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
5644 i_ehdrp = elf_elfheader (abfd);
5646 /* Put an ABI label supported by FreeBSD >= 4.1. */
5647 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
5648 #ifdef OLD_FREEBSD_ABI_LABEL
5649 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5650 memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5654 #undef elf_backend_post_process_headers
5655 #define elf_backend_post_process_headers \
5656 elf64_alpha_fbsd_post_process_headers
5659 #define elf64_bed elf64_alpha_fbsd_bed
5661 #include "elf64-target.h"