1 /* Alpha specific support for 64-bit ELF
2 Copyright 1996, 97, 98, 1999 Free Software Foundation, Inc.
3 Contributed by Richard Henderson <rth@tamu.edu>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* We need a published ABI spec for this. Until one comes out, don't
22 assume this'll remain unchanged forever. */
29 #include "elf/alpha.h"
33 #define NO_COFF_RELOCS
34 #define NO_COFF_SYMBOLS
35 #define NO_COFF_LINENOS
37 /* Get the ECOFF swapping routines. Needed for the debug information. */
38 #include "coff/internal.h"
40 #include "coff/symconst.h"
41 #include "coff/ecoff.h"
42 #include "coff/alpha.h"
47 #include "ecoffswap.h"
49 static int alpha_elf_dynamic_symbol_p
50 PARAMS((struct elf_link_hash_entry *, struct bfd_link_info *));
51 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
52 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
53 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
56 static bfd_reloc_status_type elf64_alpha_reloc_nil
57 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
58 static bfd_reloc_status_type elf64_alpha_reloc_bad
59 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
60 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
61 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
62 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
63 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
65 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
66 PARAMS((bfd *, bfd_reloc_code_real_type));
67 static void elf64_alpha_info_to_howto
68 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
70 static boolean elf64_alpha_mkobject
72 static boolean elf64_alpha_object_p
74 static boolean elf64_alpha_section_from_shdr
75 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
76 static boolean elf64_alpha_fake_sections
77 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
78 static boolean elf64_alpha_create_got_section
79 PARAMS((bfd *, struct bfd_link_info *));
80 static boolean elf64_alpha_create_dynamic_sections
81 PARAMS((bfd *, struct bfd_link_info *));
83 static boolean elf64_alpha_read_ecoff_info
84 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
85 static boolean elf64_alpha_is_local_label_name
86 PARAMS((bfd *, const char *));
87 static boolean elf64_alpha_find_nearest_line
88 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
89 const char **, unsigned int *));
91 #if defined(__STDC__) || defined(ALMOST_STDC)
92 struct alpha_elf_link_hash_entry;
95 static boolean elf64_alpha_output_extsym
96 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
98 static boolean elf64_alpha_can_merge_gots
99 PARAMS((bfd *, bfd *));
100 static void elf64_alpha_merge_gots
101 PARAMS((bfd *, bfd *));
102 static boolean elf64_alpha_calc_got_offsets_for_symbol
103 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
104 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
105 static boolean elf64_alpha_size_got_sections
106 PARAMS ((bfd *, struct bfd_link_info *));
107 static boolean elf64_alpha_always_size_sections
108 PARAMS ((bfd *, struct bfd_link_info *));
109 static boolean elf64_alpha_calc_dynrel_sizes
110 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
111 static boolean elf64_alpha_add_symbol_hook
112 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
113 const char **, flagword *, asection **, bfd_vma *));
114 static boolean elf64_alpha_check_relocs
115 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
116 const Elf_Internal_Rela *));
117 static boolean elf64_alpha_adjust_dynamic_symbol
118 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
119 static boolean elf64_alpha_size_dynamic_sections
120 PARAMS((bfd *, struct bfd_link_info *));
121 static boolean elf64_alpha_relocate_section
122 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
123 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
124 static boolean elf64_alpha_finish_dynamic_symbol
125 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
126 Elf_Internal_Sym *));
127 static boolean elf64_alpha_finish_dynamic_sections
128 PARAMS((bfd *, struct bfd_link_info *));
129 static boolean elf64_alpha_final_link
130 PARAMS((bfd *, struct bfd_link_info *));
131 static boolean elf64_alpha_merge_ind_symbols
132 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
133 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
134 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
136 struct alpha_elf_link_hash_entry
138 struct elf_link_hash_entry root;
140 /* External symbol information. */
143 /* Cumulative flags for all the .got entries. */
146 /* Contexts (LITUSE) in which a literal was referenced. */
147 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
148 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
149 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
150 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
152 /* Used to implement multiple .got subsections. */
153 struct alpha_elf_got_entry
155 struct alpha_elf_got_entry *next;
157 /* which .got subsection? */
160 /* the addend in effect for this entry. */
163 /* the .got offset for this entry. */
168 /* An additional flag. */
169 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
174 /* used to count non-got, non-plt relocations for delayed sizing
175 of relocation sections. */
176 struct alpha_elf_reloc_entry
178 struct alpha_elf_reloc_entry *next;
180 /* which .reloc section? */
183 /* what kind of relocation? */
186 /* how many did we find? */
191 /* Alpha ELF linker hash table. */
193 struct alpha_elf_link_hash_table
195 struct elf_link_hash_table root;
197 /* The head of a list of .got subsections linked through
198 alpha_elf_tdata(abfd)->got_link_next. */
202 /* Look up an entry in a Alpha ELF linker hash table. */
204 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
205 ((struct alpha_elf_link_hash_entry *) \
206 elf_link_hash_lookup (&(table)->root, (string), (create), \
209 /* Traverse a Alpha ELF linker hash table. */
211 #define alpha_elf_link_hash_traverse(table, func, info) \
212 (elf_link_hash_traverse \
214 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
217 /* Get the Alpha ELF linker hash table from a link_info structure. */
219 #define alpha_elf_hash_table(p) \
220 ((struct alpha_elf_link_hash_table *) ((p)->hash))
222 /* Get the object's symbols as our own entry type. */
224 #define alpha_elf_sym_hashes(abfd) \
225 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
227 /* Should we do dynamic things to this symbol? */
230 alpha_elf_dynamic_symbol_p (h, info)
231 struct elf_link_hash_entry *h;
232 struct bfd_link_info *info;
237 while (h->root.type == bfd_link_hash_indirect
238 || h->root.type == bfd_link_hash_warning)
239 h = (struct elf_link_hash_entry *) h->root.u.i.link;
241 if (h->dynindx == -1)
243 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
246 if (h->root.type == bfd_link_hash_undefweak
247 || h->root.type == bfd_link_hash_defweak)
250 if ((info->shared && !info->symbolic)
251 || ((h->elf_link_hash_flags
252 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
253 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
259 /* Create an entry in a Alpha ELF linker hash table. */
261 static struct bfd_hash_entry *
262 elf64_alpha_link_hash_newfunc (entry, table, string)
263 struct bfd_hash_entry *entry;
264 struct bfd_hash_table *table;
267 struct alpha_elf_link_hash_entry *ret =
268 (struct alpha_elf_link_hash_entry *) entry;
270 /* Allocate the structure if it has not already been allocated by a
272 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
273 ret = ((struct alpha_elf_link_hash_entry *)
274 bfd_hash_allocate (table,
275 sizeof (struct alpha_elf_link_hash_entry)));
276 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
277 return (struct bfd_hash_entry *) ret;
279 /* Call the allocation method of the superclass. */
280 ret = ((struct alpha_elf_link_hash_entry *)
281 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
283 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
285 /* Set local fields. */
286 memset (&ret->esym, 0, sizeof (EXTR));
287 /* We use -2 as a marker to indicate that the information has
288 not been set. -1 means there is no associated ifd. */
291 ret->got_entries = NULL;
292 ret->reloc_entries = NULL;
295 return (struct bfd_hash_entry *) ret;
298 /* Create a Alpha ELF linker hash table. */
300 static struct bfd_link_hash_table *
301 elf64_alpha_bfd_link_hash_table_create (abfd)
304 struct alpha_elf_link_hash_table *ret;
306 ret = ((struct alpha_elf_link_hash_table *)
307 bfd_zalloc (abfd, sizeof (struct alpha_elf_link_hash_table)));
308 if (ret == (struct alpha_elf_link_hash_table *) NULL)
311 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
312 elf64_alpha_link_hash_newfunc))
314 bfd_release (abfd, ret);
318 return &ret->root.root;
321 /* We have some private fields hanging off of the elf_tdata structure. */
323 struct alpha_elf_obj_tdata
325 struct elf_obj_tdata root;
327 /* For every input file, these are the got entries for that object's
329 struct alpha_elf_got_entry ** local_got_entries;
331 /* For every input file, this is the object that owns the got that
332 this input file uses. */
335 /* For every got, this is a linked list through the objects using this got */
336 bfd *in_got_link_next;
338 /* For every got, this is a link to the next got subsegment. */
341 /* For every got, this is the section. */
344 /* For every got, this is it's total number of *entries*. */
345 int total_got_entries;
347 /* For every got, this is the sum of the number of *entries* required
348 to hold all of the member object's local got. */
349 int n_local_got_entries;
352 #define alpha_elf_tdata(abfd) \
353 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
356 elf64_alpha_mkobject (abfd)
359 abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
360 if (abfd->tdata.any == NULL)
366 elf64_alpha_object_p (abfd)
369 /* Allocate our special target data. */
370 struct alpha_elf_obj_tdata *new_tdata;
371 new_tdata = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
372 if (new_tdata == NULL)
374 new_tdata->root = *abfd->tdata.elf_obj_data;
375 abfd->tdata.any = new_tdata;
377 /* Set the right machine number for an Alpha ELF file. */
378 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
381 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
382 from smaller values. Start with zero, widen, *then* decrement. */
383 #define MINUS_ONE (((bfd_vma)0) - 1)
385 static reloc_howto_type elf64_alpha_howto_table[] =
387 HOWTO (R_ALPHA_NONE, /* type */
389 0, /* size (0 = byte, 1 = short, 2 = long) */
391 true, /* pc_relative */
393 complain_overflow_dont, /* complain_on_overflow */
394 elf64_alpha_reloc_nil, /* special_function */
396 false, /* partial_inplace */
399 true), /* pcrel_offset */
401 /* A 32 bit reference to a symbol. */
402 HOWTO (R_ALPHA_REFLONG, /* type */
404 2, /* size (0 = byte, 1 = short, 2 = long) */
406 false, /* pc_relative */
408 complain_overflow_bitfield, /* complain_on_overflow */
409 0, /* special_function */
410 "REFLONG", /* name */
411 false, /* partial_inplace */
412 0xffffffff, /* src_mask */
413 0xffffffff, /* dst_mask */
414 false), /* pcrel_offset */
416 /* A 64 bit reference to a symbol. */
417 HOWTO (R_ALPHA_REFQUAD, /* type */
419 4, /* size (0 = byte, 1 = short, 2 = long) */
421 false, /* pc_relative */
423 complain_overflow_bitfield, /* complain_on_overflow */
424 0, /* special_function */
425 "REFQUAD", /* name */
426 false, /* partial_inplace */
427 MINUS_ONE, /* src_mask */
428 MINUS_ONE, /* dst_mask */
429 false), /* pcrel_offset */
431 /* A 32 bit GP relative offset. This is just like REFLONG except
432 that when the value is used the value of the gp register will be
434 HOWTO (R_ALPHA_GPREL32, /* type */
436 2, /* size (0 = byte, 1 = short, 2 = long) */
438 false, /* pc_relative */
440 complain_overflow_bitfield, /* complain_on_overflow */
441 0, /* special_function */
442 "GPREL32", /* name */
443 false, /* partial_inplace */
444 0xffffffff, /* src_mask */
445 0xffffffff, /* dst_mask */
446 false), /* pcrel_offset */
448 /* Used for an instruction that refers to memory off the GP register. */
449 HOWTO (R_ALPHA_LITERAL, /* type */
451 2, /* size (0 = byte, 1 = short, 2 = long) */
453 false, /* pc_relative */
455 complain_overflow_signed, /* complain_on_overflow */
456 0, /* special_function */
457 "ELF_LITERAL", /* name */
458 false, /* partial_inplace */
459 0xffff, /* src_mask */
460 0xffff, /* dst_mask */
461 false), /* pcrel_offset */
463 /* This reloc only appears immediately following an ELF_LITERAL reloc.
464 It identifies a use of the literal. The symbol index is special:
465 1 means the literal address is in the base register of a memory
466 format instruction; 2 means the literal address is in the byte
467 offset register of a byte-manipulation instruction; 3 means the
468 literal address is in the target register of a jsr instruction.
469 This does not actually do any relocation. */
470 HOWTO (R_ALPHA_LITUSE, /* type */
472 2, /* size (0 = byte, 1 = short, 2 = long) */
474 false, /* pc_relative */
476 complain_overflow_dont, /* complain_on_overflow */
477 elf64_alpha_reloc_nil, /* special_function */
479 false, /* partial_inplace */
482 false), /* pcrel_offset */
484 /* Load the gp register. This is always used for a ldah instruction
485 which loads the upper 16 bits of the gp register. The symbol
486 index of the GPDISP instruction is an offset in bytes to the lda
487 instruction that loads the lower 16 bits. The value to use for
488 the relocation is the difference between the GP value and the
489 current location; the load will always be done against a register
490 holding the current address.
492 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
493 any offset is present in the instructions, it is an offset from
494 the register to the ldah instruction. This lets us avoid any
495 stupid hackery like inventing a gp value to do partial relocation
496 against. Also unlike ECOFF, we do the whole relocation off of
497 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
498 space consuming bit, that, since all the information was present
499 in the GPDISP_HI16 reloc. */
500 HOWTO (R_ALPHA_GPDISP, /* type */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
504 false, /* pc_relative */
506 complain_overflow_dont, /* complain_on_overflow */
507 elf64_alpha_reloc_gpdisp, /* special_function */
509 false, /* partial_inplace */
510 0xffff, /* src_mask */
511 0xffff, /* dst_mask */
512 true), /* pcrel_offset */
514 /* A 21 bit branch. */
515 HOWTO (R_ALPHA_BRADDR, /* type */
517 2, /* size (0 = byte, 1 = short, 2 = long) */
519 true, /* pc_relative */
521 complain_overflow_signed, /* complain_on_overflow */
522 0, /* special_function */
524 false, /* partial_inplace */
525 0x1fffff, /* src_mask */
526 0x1fffff, /* dst_mask */
527 true), /* pcrel_offset */
529 /* A hint for a jump to a register. */
530 HOWTO (R_ALPHA_HINT, /* type */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
534 true, /* pc_relative */
536 complain_overflow_dont, /* complain_on_overflow */
537 0, /* special_function */
539 false, /* partial_inplace */
540 0x3fff, /* src_mask */
541 0x3fff, /* dst_mask */
542 true), /* pcrel_offset */
544 /* 16 bit PC relative offset. */
545 HOWTO (R_ALPHA_SREL16, /* type */
547 1, /* size (0 = byte, 1 = short, 2 = long) */
549 true, /* pc_relative */
551 complain_overflow_signed, /* complain_on_overflow */
552 0, /* special_function */
554 false, /* partial_inplace */
555 0xffff, /* src_mask */
556 0xffff, /* dst_mask */
557 false), /* pcrel_offset */
559 /* 32 bit PC relative offset. */
560 HOWTO (R_ALPHA_SREL32, /* type */
562 2, /* size (0 = byte, 1 = short, 2 = long) */
564 true, /* pc_relative */
566 complain_overflow_signed, /* complain_on_overflow */
567 0, /* special_function */
569 false, /* partial_inplace */
570 0xffffffff, /* src_mask */
571 0xffffffff, /* dst_mask */
572 false), /* pcrel_offset */
574 /* A 64 bit PC relative offset. */
575 HOWTO (R_ALPHA_SREL64, /* type */
577 4, /* size (0 = byte, 1 = short, 2 = long) */
579 true, /* pc_relative */
581 complain_overflow_signed, /* complain_on_overflow */
582 0, /* special_function */
584 false, /* partial_inplace */
585 MINUS_ONE, /* src_mask */
586 MINUS_ONE, /* dst_mask */
587 false), /* pcrel_offset */
589 /* Push a value on the reloc evaluation stack. */
590 /* Not implemented -- it's dumb. */
591 HOWTO (R_ALPHA_OP_PUSH, /* type */
593 0, /* size (0 = byte, 1 = short, 2 = long) */
595 false, /* pc_relative */
597 complain_overflow_dont, /* complain_on_overflow */
598 elf64_alpha_reloc_bad, /* special_function */
599 "OP_PUSH", /* name */
600 false, /* partial_inplace */
603 false), /* pcrel_offset */
605 /* Store the value from the stack at the given address. Store it in
606 a bitfield of size r_size starting at bit position r_offset. */
607 /* Not implemented -- it's dumb. */
608 HOWTO (R_ALPHA_OP_STORE, /* type */
610 4, /* size (0 = byte, 1 = short, 2 = long) */
612 false, /* pc_relative */
614 complain_overflow_dont, /* complain_on_overflow */
615 elf64_alpha_reloc_bad, /* special_function */
616 "OP_STORE", /* name */
617 false, /* partial_inplace */
619 MINUS_ONE, /* dst_mask */
620 false), /* pcrel_offset */
622 /* Subtract the reloc address from the value on the top of the
624 /* Not implemented -- it's dumb. */
625 HOWTO (R_ALPHA_OP_PSUB, /* type */
627 0, /* size (0 = byte, 1 = short, 2 = long) */
629 false, /* pc_relative */
631 complain_overflow_dont, /* complain_on_overflow */
632 elf64_alpha_reloc_bad, /* special_function */
633 "OP_PSUB", /* name */
634 false, /* partial_inplace */
637 false), /* pcrel_offset */
639 /* Shift the value on the top of the relocation stack right by the
641 /* Not implemented -- it's dumb. */
642 HOWTO (R_ALPHA_OP_PRSHIFT, /* type */
644 0, /* size (0 = byte, 1 = short, 2 = long) */
646 false, /* pc_relative */
648 complain_overflow_dont, /* complain_on_overflow */
649 elf64_alpha_reloc_bad, /* special_function */
650 "OP_PRSHIFT", /* name */
651 false, /* partial_inplace */
654 false), /* pcrel_offset */
656 /* Change the value of GP used by +r_addend until the next GPVALUE or the
657 end of the input bfd. */
658 /* Not implemented -- it's dumb. */
659 HOWTO (R_ALPHA_GPVALUE,
661 0, /* size (0 = byte, 1 = short, 2 = long) */
663 false, /* pc_relative */
665 complain_overflow_dont, /* complain_on_overflow */
666 elf64_alpha_reloc_bad, /* special_function */
667 "GPVALUE", /* name */
668 false, /* partial_inplace */
671 false), /* pcrel_offset */
673 /* The high 16 bits of the displacement from GP to the target. */
674 HOWTO (R_ALPHA_GPRELHIGH,
676 2, /* size (0 = byte, 1 = short, 2 = long) */
678 false, /* pc_relative */
680 complain_overflow_signed, /* complain_on_overflow */
681 elf64_alpha_reloc_bad, /* special_function */
682 "GPRELHIGH", /* name */
683 false, /* partial_inplace */
684 0xffff, /* src_mask */
685 0xffff, /* dst_mask */
686 false), /* pcrel_offset */
688 /* The low 16 bits of the displacement from GP to the target. */
689 HOWTO (R_ALPHA_GPRELLOW,
691 2, /* size (0 = byte, 1 = short, 2 = long) */
693 false, /* pc_relative */
695 complain_overflow_dont, /* complain_on_overflow */
696 elf64_alpha_reloc_bad, /* special_function */
697 "GPRELLOW", /* name */
698 false, /* partial_inplace */
699 0xffff, /* src_mask */
700 0xffff, /* dst_mask */
701 false), /* pcrel_offset */
703 /* A 16-bit displacement from the GP to the target. */
704 /* XXX: Not implemented. */
705 HOWTO (R_ALPHA_IMMED_GP_16,
707 2, /* size (0 = byte, 1 = short, 2 = long) */
709 false, /* pc_relative */
711 complain_overflow_signed, /* complain_on_overflow */
712 0, /* special_function */
713 "IMMED_GP_16", /* name */
714 false, /* partial_inplace */
715 0xffff, /* src_mask */
716 0xffff, /* dst_mask */
717 false), /* pcrel_offset */
719 /* The high bits of a 32-bit displacement from the GP to the target; the
720 low bits are supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
721 /* XXX: Not implemented. */
722 HOWTO (R_ALPHA_IMMED_GP_HI32,
724 0, /* size (0 = byte, 1 = short, 2 = long) */
726 false, /* pc_relative */
728 complain_overflow_dont, /* complain_on_overflow */
729 elf64_alpha_reloc_bad, /* special_function */
730 "IMMED_GP_HI32", /* name */
731 false, /* partial_inplace */
734 false), /* pcrel_offset */
736 /* The high bits of a 32-bit displacement to the starting address of the
737 current section (the relocation target is ignored); the low bits are
738 supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
739 /* XXX: Not implemented. */
740 HOWTO (R_ALPHA_IMMED_SCN_HI32,
742 0, /* size (0 = byte, 1 = short, 2 = long) */
744 false, /* pc_relative */
746 complain_overflow_dont, /* complain_on_overflow */
747 elf64_alpha_reloc_bad, /* special_function */
748 "IMMED_SCN_HI32", /* name */
749 false, /* partial_inplace */
752 false), /* pcrel_offset */
754 /* The high bits of a 32-bit displacement from the previous br, bsr, jsr
755 or jmp insn (as tagged by a BRADDR or HINT reloc) to the target; the
756 low bits are supplied by subsequent R_ALPHA_IMMED_LO32 relocs. */
757 /* XXX: Not implemented. */
758 HOWTO (R_ALPHA_IMMED_BR_HI32,
760 0, /* size (0 = byte, 1 = short, 2 = long) */
762 false, /* pc_relative */
764 complain_overflow_dont, /* complain_on_overflow */
765 elf64_alpha_reloc_bad, /* special_function */
766 "IMMED_BR_HI32", /* name */
767 false, /* partial_inplace */
770 false), /* pcrel_offset */
772 /* The low 16 bits of a displacement calculated in a previous HI32 reloc. */
773 /* XXX: Not implemented. */
774 HOWTO (R_ALPHA_IMMED_LO32,
776 0, /* size (0 = byte, 1 = short, 2 = long) */
778 false, /* pc_relative */
780 complain_overflow_dont, /* complain_on_overflow */
781 elf64_alpha_reloc_bad, /* special_function */
782 "IMMED_LO32", /* name */
783 false, /* partial_inplace */
786 false), /* pcrel_offset */
788 /* Misc ELF relocations. */
790 /* A dynamic relocation to copy the target into our .dynbss section. */
791 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
792 is present because every other ELF has one, but should not be used
793 because .dynbss is an ugly thing. */
800 complain_overflow_dont,
801 bfd_elf_generic_reloc,
808 /* A dynamic relocation for a .got entry. */
809 HOWTO (R_ALPHA_GLOB_DAT,
815 complain_overflow_dont,
816 bfd_elf_generic_reloc,
823 /* A dynamic relocation for a .plt entry. */
824 HOWTO (R_ALPHA_JMP_SLOT,
830 complain_overflow_dont,
831 bfd_elf_generic_reloc,
838 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
839 HOWTO (R_ALPHA_RELATIVE,
845 complain_overflow_dont,
846 bfd_elf_generic_reloc,
854 /* A relocation function which doesn't do anything. */
856 static bfd_reloc_status_type
857 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
864 char **error_message;
867 reloc->address += sec->output_offset;
871 /* A relocation function used for an unsupported reloc. */
873 static bfd_reloc_status_type
874 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
881 char **error_message;
884 reloc->address += sec->output_offset;
885 return bfd_reloc_notsupported;
888 /* Do the work of the GPDISP relocation. */
890 static bfd_reloc_status_type
891 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
897 bfd_reloc_status_type ret = bfd_reloc_ok;
899 unsigned long i_ldah, i_lda;
901 i_ldah = bfd_get_32 (abfd, p_ldah);
902 i_lda = bfd_get_32 (abfd, p_lda);
904 /* Complain if the instructions are not correct. */
905 if (((i_ldah >> 26) & 0x3f) != 0x09
906 || ((i_lda >> 26) & 0x3f) != 0x08)
907 ret = bfd_reloc_dangerous;
909 /* Extract the user-supplied offset, mirroring the sign extensions
910 that the instructions perform. */
911 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
912 addend = (addend ^ 0x80008000) - 0x80008000;
916 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
917 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
918 ret = bfd_reloc_overflow;
920 /* compensate for the sign extension again. */
921 i_ldah = ((i_ldah & 0xffff0000)
922 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
923 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
925 bfd_put_32 (abfd, i_ldah, p_ldah);
926 bfd_put_32 (abfd, i_lda, p_lda);
931 /* The special function for the GPDISP reloc. */
933 static bfd_reloc_status_type
934 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
937 arelent *reloc_entry;
940 asection *input_section;
944 bfd_reloc_status_type ret;
945 bfd_vma gp, relocation;
946 bfd_byte *p_ldah, *p_lda;
948 /* Don't do anything if we're not doing a final link. */
951 reloc_entry->address += input_section->output_offset;
955 if (reloc_entry->address > input_section->_cooked_size ||
956 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
957 return bfd_reloc_outofrange;
959 /* The gp used in the portion of the output object to which this
960 input object belongs is cached on the input bfd. */
961 gp = _bfd_get_gp_value (abfd);
963 relocation = (input_section->output_section->vma
964 + input_section->output_offset
965 + reloc_entry->address);
967 p_ldah = (bfd_byte *) data + reloc_entry->address;
968 p_lda = p_ldah + reloc_entry->addend;
970 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
972 /* Complain if the instructions are not correct. */
973 if (ret == bfd_reloc_dangerous)
974 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
979 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
983 bfd_reloc_code_real_type bfd_reloc_val;
987 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
989 {BFD_RELOC_NONE, R_ALPHA_NONE},
990 {BFD_RELOC_32, R_ALPHA_REFLONG},
991 {BFD_RELOC_64, R_ALPHA_REFQUAD},
992 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
993 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
994 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
995 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
996 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
997 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
998 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
999 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
1000 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
1001 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
1003 /* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process
1004 the explicit !<reloc>!sequence relocations, and are mapped into the normal
1005 relocations at the end of processing. */
1006 {BFD_RELOC_ALPHA_USER_LITERAL, R_ALPHA_LITERAL},
1007 {BFD_RELOC_ALPHA_USER_LITUSE_BASE, R_ALPHA_LITUSE},
1008 {BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF, R_ALPHA_LITUSE},
1009 {BFD_RELOC_ALPHA_USER_LITUSE_JSR, R_ALPHA_LITUSE},
1010 {BFD_RELOC_ALPHA_USER_GPDISP, R_ALPHA_GPDISP},
1011 {BFD_RELOC_ALPHA_USER_GPRELHIGH, R_ALPHA_GPRELHIGH},
1012 {BFD_RELOC_ALPHA_USER_GPRELLOW, R_ALPHA_GPRELLOW},
1015 /* Given a BFD reloc type, return a HOWTO structure. */
1017 static reloc_howto_type *
1018 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
1020 bfd_reloc_code_real_type code;
1022 const struct elf_reloc_map *i, *e;
1023 i = e = elf64_alpha_reloc_map;
1024 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1027 if (i->bfd_reloc_val == code)
1028 return &elf64_alpha_howto_table[i->elf_reloc_val];
1033 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1036 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
1039 Elf64_Internal_Rela *dst;
1043 r_type = ELF64_R_TYPE(dst->r_info);
1044 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
1045 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1048 /* These functions do relaxation for Alpha ELF.
1050 Currently I'm only handling what I can do with existing compiler
1051 and assembler support, which means no instructions are removed,
1052 though some may be nopped. At this time GCC does not emit enough
1053 information to do all of the relaxing that is possible. It will
1054 take some not small amount of work for that to happen.
1056 There are a couple of interesting papers that I once read on this
1057 subject, that I cannot find references to at the moment, that
1058 related to Alpha in particular. They are by David Wall, then of
1062 #define OP_LDAH 0x09
1063 #define INSN_JSR 0x68004000
1064 #define INSN_JSR_MASK 0xfc00c000
1068 #define INSN_UNOP 0x2fe00000
1070 struct alpha_relax_info
1075 Elf_Internal_Rela *relocs, *relend;
1076 struct bfd_link_info *link_info;
1077 boolean changed_contents;
1078 boolean changed_relocs;
1082 struct alpha_elf_link_hash_entry *h;
1083 struct alpha_elf_got_entry *gotent;
1084 unsigned char other;
1087 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
1088 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1089 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
1091 static boolean elf64_alpha_relax_without_lituse
1092 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1093 Elf_Internal_Rela *irel));
1095 static bfd_vma elf64_alpha_relax_opt_call
1096 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
1098 static boolean elf64_alpha_relax_section
1099 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
1102 static Elf_Internal_Rela *
1103 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
1104 Elf_Internal_Rela *rel, *relend;
1108 while (rel < relend)
1110 if (rel->r_offset == offset && ELF64_R_TYPE (rel->r_info) == type)
1117 static Elf_Internal_Rela *
1118 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1119 struct alpha_relax_info *info;
1121 Elf_Internal_Rela *irel, *irelend;
1123 Elf_Internal_Rela *urel;
1124 int flags, count, i;
1125 bfd_signed_vma disp;
1128 boolean lit_reused = false;
1129 boolean all_optimized = true;
1130 unsigned int lit_insn;
1132 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1133 if (lit_insn >> 26 != OP_LDQ)
1135 ((*_bfd_error_handler)
1136 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1137 bfd_get_filename (info->abfd), info->sec->name,
1138 (unsigned long)irel->r_offset));
1142 /* Summarize how this particular LITERAL is used. */
1143 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1145 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1147 if (urel->r_addend >= 0 && urel->r_addend <= 3)
1148 flags |= 1 << urel->r_addend;
1151 /* A little preparation for the loop... */
1152 disp = symval - info->gp;
1154 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1158 bfd_signed_vma xdisp;
1160 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1162 switch (urel->r_addend)
1164 default: /* 0 = ADDRESS FORMAT */
1165 /* This type is really just a placeholder to note that all
1166 uses cannot be optimized, but to still allow some. */
1167 all_optimized = false;
1170 case 1: /* MEM FORMAT */
1171 /* We can always optimize 16-bit displacements. */
1173 /* Extract the displacement from the instruction, sign-extending
1174 it if necessary, then test whether it is within 16 or 32 bits
1175 displacement from GP. */
1176 insn_disp = insn & 0x0000ffff;
1177 if (insn_disp & 0x00008000)
1178 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1180 xdisp = disp + insn_disp;
1181 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1182 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1186 /* Take the op code and dest from this insn, take the base
1187 register from the literal insn. Leave the offset alone. */
1188 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1189 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1191 urel->r_addend = irel->r_addend;
1192 info->changed_relocs = true;
1194 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1195 info->changed_contents = true;
1198 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1199 else if (fits32 && !(flags & ~6))
1201 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1203 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1205 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1206 bfd_put_32 (info->abfd, lit_insn,
1207 info->contents + irel->r_offset);
1209 info->changed_contents = true;
1211 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1213 urel->r_addend = irel->r_addend;
1214 info->changed_relocs = true;
1217 all_optimized = false;
1220 case 2: /* BYTE OFFSET FORMAT */
1221 /* We can always optimize byte instructions. */
1223 /* FIXME: sanity check the insn for byte op. Check that the
1224 literal dest reg is indeed Rb in the byte insn. */
1226 insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
1228 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1230 info->changed_relocs = true;
1232 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1233 info->changed_contents = true;
1236 case 3: /* CALL FORMAT */
1238 /* If not zero, place to jump without needing pv. */
1239 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1240 bfd_vma org = (info->sec->output_section->vma
1241 + info->sec->output_offset
1242 + urel->r_offset + 4);
1243 bfd_signed_vma odisp;
1245 odisp = (optdest ? optdest : symval) - org;
1246 if (odisp >= -0x400000 && odisp < 0x400000)
1248 Elf_Internal_Rela *xrel;
1250 /* Preserve branch prediction call stack when possible. */
1251 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1252 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1254 insn = (OP_BR << 26) | (insn & 0x03e00000);
1256 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1258 urel->r_addend = irel->r_addend;
1261 urel->r_addend += optdest - symval;
1263 all_optimized = false;
1265 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1267 /* Kill any HINT reloc that might exist for this insn. */
1268 xrel = (elf64_alpha_find_reloc_at_ofs
1269 (info->relocs, info->relend, urel->r_offset,
1272 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1274 info->changed_contents = true;
1275 info->changed_relocs = true;
1278 all_optimized = false;
1280 /* ??? If target gp == current gp we can eliminate the gp reload.
1281 This does depend on every place a gp could be reloaded will
1282 be, which currently happens for all code produced by gcc, but
1283 not necessarily by hand-coded assembly, or if sibling calls
1286 Perhaps conditionalize this on a flag being set in the target
1287 object file's header, and have gcc set it? */
1293 /* If all cases were optimized, we can reduce the use count on this
1294 got entry by one, possibly eliminating it. */
1297 info->gotent->use_count -= 1;
1298 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1300 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1302 /* If the literal instruction is no longer needed (it may have been
1303 reused. We can eliminate it.
1304 ??? For now, I don't want to deal with compacting the section,
1305 so just nop it out. */
1308 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1309 info->changed_relocs = true;
1311 bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
1312 info->changed_contents = true;
1316 return irel + count;
1320 elf64_alpha_relax_opt_call (info, symval)
1321 struct alpha_relax_info *info;
1324 /* If the function has the same gp, and we can identify that the
1325 function does not use its function pointer, we can eliminate the
1328 /* If the symbol is marked NOPV, we are being told the function never
1329 needs its procedure value. */
1330 if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
1333 /* If the symbol is marked STD_GP, we are being told the function does
1334 a normal ldgp in the first two words. */
1335 else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
1338 /* Otherwise, we may be able to identify a GP load in the first two
1339 words, which we can then skip. */
1342 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1345 /* Load the relocations from the section that the target symbol is in. */
1346 if (info->sec == info->tsec)
1348 tsec_relocs = info->relocs;
1349 tsec_relend = info->relend;
1354 tsec_relocs = (_bfd_elf64_link_read_relocs
1355 (info->abfd, info->tsec, (PTR) NULL,
1356 (Elf_Internal_Rela *) NULL,
1357 info->link_info->keep_memory));
1358 if (tsec_relocs == NULL)
1360 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1361 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1364 /* Recover the symbol's offset within the section. */
1365 ofs = (symval - info->tsec->output_section->vma
1366 - info->tsec->output_offset);
1368 /* Look for a GPDISP reloc. */
1369 gpdisp = (elf64_alpha_find_reloc_at_ofs
1370 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1372 if (!gpdisp || gpdisp->r_addend != 4)
1382 /* We've now determined that we can skip an initial gp load. Verify
1383 that the call and the target use the same gp. */
1384 if (info->link_info->hash->creator != info->tsec->owner->xvec
1385 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1392 elf64_alpha_relax_without_lituse (info, symval, irel)
1393 struct alpha_relax_info *info;
1395 Elf_Internal_Rela *irel;
1398 bfd_signed_vma disp;
1400 /* Get the instruction. */
1401 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1403 if (insn >> 26 != OP_LDQ)
1405 ((*_bfd_error_handler)
1406 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1407 bfd_get_filename (info->abfd), info->sec->name,
1408 (unsigned long) irel->r_offset));
1412 /* So we aren't told much. Do what we can with the address load and
1413 fake the rest. All of the optimizations here require that the
1414 offset from the GP fit in 16 bits. */
1416 disp = symval - info->gp;
1417 if (disp < -0x8000 || disp >= 0x8000)
1420 /* On the LITERAL instruction itself, consider exchanging
1421 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1423 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1424 bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
1425 info->changed_contents = true;
1427 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELLOW);
1428 info->changed_relocs = true;
1430 /* Reduce the use count on this got entry by one, possibly
1432 info->gotent->use_count -= 1;
1433 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1435 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1437 /* ??? Search forward through this basic block looking for insns
1438 that use the target register. Stop after an insn modifying the
1439 register is seen, or after a branch or call.
1441 Any such memory load insn may be substituted by a load directly
1442 off the GP. This allows the memory load insn to be issued before
1443 the calculated GP register would otherwise be ready.
1445 Any such jsr insn can be replaced by a bsr if it is in range.
1447 This would mean that we'd have to _add_ relocations, the pain of
1448 which gives one pause. */
1454 elf64_alpha_relax_section (abfd, sec, link_info, again)
1457 struct bfd_link_info *link_info;
1460 Elf_Internal_Shdr *symtab_hdr;
1461 Elf_Internal_Rela *internal_relocs;
1462 Elf_Internal_Rela *free_relocs = NULL;
1463 Elf_Internal_Rela *irel, *irelend;
1464 bfd_byte *free_contents = NULL;
1465 Elf64_External_Sym *extsyms = NULL;
1466 Elf64_External_Sym *free_extsyms = NULL;
1467 struct alpha_elf_got_entry **local_got_entries;
1468 struct alpha_relax_info info;
1470 /* We are not currently changing any sizes, so only one pass. */
1473 if (link_info->relocateable
1474 || (sec->flags & SEC_RELOC) == 0
1475 || sec->reloc_count == 0)
1478 /* If this is the first time we have been called for this section,
1479 initialize the cooked size. */
1480 if (sec->_cooked_size == 0)
1481 sec->_cooked_size = sec->_raw_size;
1483 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1484 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1486 /* Load the relocations for this section. */
1487 internal_relocs = (_bfd_elf64_link_read_relocs
1488 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1489 link_info->keep_memory));
1490 if (internal_relocs == NULL)
1492 if (! link_info->keep_memory)
1493 free_relocs = internal_relocs;
1495 memset(&info, 0, sizeof (info));
1498 info.link_info = link_info;
1499 info.relocs = internal_relocs;
1500 info.relend = irelend = internal_relocs + sec->reloc_count;
1502 /* Find the GP for this object. */
1503 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1506 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1507 info.gp = _bfd_get_gp_value (info.gotobj);
1510 info.gp = (sgot->output_section->vma
1511 + sgot->output_offset
1513 _bfd_set_gp_value (info.gotobj, info.gp);
1517 for (irel = internal_relocs; irel < irelend; irel++)
1520 Elf_Internal_Sym isym;
1521 struct alpha_elf_got_entry *gotent;
1523 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1526 /* Get the section contents. */
1527 if (info.contents == NULL)
1529 if (elf_section_data (sec)->this_hdr.contents != NULL)
1530 info.contents = elf_section_data (sec)->this_hdr.contents;
1533 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1534 if (info.contents == NULL)
1536 free_contents = info.contents;
1538 if (! bfd_get_section_contents (abfd, sec, info.contents,
1539 (file_ptr) 0, sec->_raw_size))
1544 /* Read this BFD's symbols if we haven't done so already. */
1545 if (extsyms == NULL)
1547 if (symtab_hdr->contents != NULL)
1548 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1551 extsyms = ((Elf64_External_Sym *)
1552 bfd_malloc (symtab_hdr->sh_size));
1553 if (extsyms == NULL)
1555 free_extsyms = extsyms;
1556 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1557 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1558 != symtab_hdr->sh_size))
1563 /* Get the value of the symbol referred to by the reloc. */
1564 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1566 /* A local symbol. */
1567 bfd_elf64_swap_symbol_in (abfd,
1568 extsyms + ELF64_R_SYM (irel->r_info),
1570 if (isym.st_shndx == SHN_UNDEF)
1571 info.tsec = bfd_und_section_ptr;
1572 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1573 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1574 else if (isym.st_shndx == SHN_ABS)
1575 info.tsec = bfd_abs_section_ptr;
1576 else if (isym.st_shndx == SHN_COMMON)
1577 info.tsec = bfd_com_section_ptr;
1579 continue; /* who knows. */
1582 info.other = isym.st_other;
1583 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1584 symval = isym.st_value;
1589 struct alpha_elf_link_hash_entry *h;
1591 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1592 h = alpha_elf_sym_hashes (abfd)[indx];
1593 BFD_ASSERT (h != NULL);
1595 while (h->root.root.type == bfd_link_hash_indirect
1596 || h->root.root.type == bfd_link_hash_warning)
1597 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1599 /* We can't do anthing with undefined or dynamic symbols. */
1600 if (h->root.root.type == bfd_link_hash_undefined
1601 || h->root.root.type == bfd_link_hash_undefweak
1602 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1606 info.gotent = gotent;
1607 info.tsec = h->root.root.u.def.section;
1608 info.other = h->root.other;
1609 gotent = h->got_entries;
1610 symval = h->root.root.u.def.value;
1613 /* Search for the got entry to be used by this relocation. */
1614 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1615 gotent = gotent->next;
1616 info.gotent = gotent;
1618 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1619 symval += irel->r_addend;
1621 BFD_ASSERT(info.gotent != NULL);
1623 /* If there exist LITUSE relocations immediately following, this
1624 opens up all sorts of interesting optimizations, because we
1625 now know every location that this address load is used. */
1627 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1629 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1635 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1640 if (!elf64_alpha_size_got_sections (abfd, link_info))
1643 if (info.changed_relocs)
1645 elf_section_data (sec)->relocs = internal_relocs;
1647 else if (free_relocs != NULL)
1652 if (info.changed_contents)
1654 elf_section_data (sec)->this_hdr.contents = info.contents;
1656 else if (free_contents != NULL)
1658 if (! link_info->keep_memory)
1659 free (free_contents);
1662 /* Cache the section contents for elf_link_input_bfd. */
1663 elf_section_data (sec)->this_hdr.contents = info.contents;
1667 if (free_extsyms != NULL)
1669 if (! link_info->keep_memory)
1670 free (free_extsyms);
1673 /* Cache the symbols for elf_link_input_bfd. */
1674 symtab_hdr->contents = extsyms;
1678 *again = info.changed_contents || info.changed_relocs;
1683 if (free_relocs != NULL)
1685 if (free_contents != NULL)
1686 free (free_contents);
1687 if (free_extsyms != NULL)
1688 free (free_extsyms);
1693 #define PLT_HEADER_SIZE 32
1694 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1695 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1696 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1697 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1699 #define PLT_ENTRY_SIZE 12
1700 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1701 #define PLT_ENTRY_WORD2 0
1702 #define PLT_ENTRY_WORD3 0
1704 #define MAX_GOT_ENTRIES (64*1024 / 8)
1706 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1708 /* Handle an Alpha specific section when reading an object file. This
1709 is called when elfcode.h finds a section with an unknown type.
1710 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1714 elf64_alpha_section_from_shdr (abfd, hdr, name)
1716 Elf64_Internal_Shdr *hdr;
1721 /* There ought to be a place to keep ELF backend specific flags, but
1722 at the moment there isn't one. We just keep track of the
1723 sections by their name, instead. Fortunately, the ABI gives
1724 suggested names for all the MIPS specific sections, so we will
1725 probably get away with this. */
1726 switch (hdr->sh_type)
1728 case SHT_ALPHA_DEBUG:
1729 if (strcmp (name, ".mdebug") != 0)
1732 #ifdef ERIC_neverdef
1733 case SHT_ALPHA_REGINFO:
1734 if (strcmp (name, ".reginfo") != 0
1735 || hdr->sh_size != sizeof (Elf64_External_RegInfo))
1743 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1745 newsect = hdr->bfd_section;
1747 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1749 if (! bfd_set_section_flags (abfd, newsect,
1750 (bfd_get_section_flags (abfd, newsect)
1755 #ifdef ERIC_neverdef
1756 /* For a .reginfo section, set the gp value in the tdata information
1757 from the contents of this section. We need the gp value while
1758 processing relocs, so we just get it now. */
1759 if (hdr->sh_type == SHT_ALPHA_REGINFO)
1761 Elf64_External_RegInfo ext;
1764 if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
1765 (file_ptr) 0, sizeof ext))
1767 bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
1768 elf_gp (abfd) = s.ri_gp_value;
1775 /* Set the correct type for an Alpha ELF section. We do this by the
1776 section name, which is a hack, but ought to work. */
1779 elf64_alpha_fake_sections (abfd, hdr, sec)
1781 Elf64_Internal_Shdr *hdr;
1784 register const char *name;
1786 name = bfd_get_section_name (abfd, sec);
1788 if (strcmp (name, ".mdebug") == 0)
1790 hdr->sh_type = SHT_ALPHA_DEBUG;
1791 /* In a shared object on Irix 5.3, the .mdebug section has an
1792 entsize of 0. FIXME: Does this matter? */
1793 if ((abfd->flags & DYNAMIC) != 0 )
1794 hdr->sh_entsize = 0;
1796 hdr->sh_entsize = 1;
1798 #ifdef ERIC_neverdef
1799 else if (strcmp (name, ".reginfo") == 0)
1801 hdr->sh_type = SHT_ALPHA_REGINFO;
1802 /* In a shared object on Irix 5.3, the .reginfo section has an
1803 entsize of 0x18. FIXME: Does this matter? */
1804 if ((abfd->flags & DYNAMIC) != 0)
1805 hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
1807 hdr->sh_entsize = 1;
1809 /* Force the section size to the correct value, even if the
1810 linker thinks it is larger. The link routine below will only
1811 write out this much data for .reginfo. */
1812 hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
1814 else if (strcmp (name, ".hash") == 0
1815 || strcmp (name, ".dynamic") == 0
1816 || strcmp (name, ".dynstr") == 0)
1818 hdr->sh_entsize = 0;
1819 hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
1822 else if (strcmp (name, ".sdata") == 0
1823 || strcmp (name, ".sbss") == 0
1824 || strcmp (name, ".lit4") == 0
1825 || strcmp (name, ".lit8") == 0)
1826 hdr->sh_flags |= SHF_ALPHA_GPREL;
1831 /* Hook called by the linker routine which adds symbols from an object
1832 file. We use it to put .comm items in .sbss, and not .bss. */
1835 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1837 struct bfd_link_info *info;
1838 const Elf_Internal_Sym *sym;
1844 if (sym->st_shndx == SHN_COMMON
1845 && !info->relocateable
1846 && sym->st_size <= bfd_get_gp_size (abfd))
1848 /* Common symbols less than or equal to -G nn bytes are
1849 automatically put into .sbss. */
1851 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1855 scomm = bfd_make_section (abfd, ".scommon");
1857 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1859 | SEC_LINKER_CREATED)))
1864 *valp = sym->st_size;
1870 /* Create the .got section. */
1873 elf64_alpha_create_got_section(abfd, info)
1875 struct bfd_link_info *info;
1879 if (bfd_get_section_by_name (abfd, ".got"))
1882 s = bfd_make_section (abfd, ".got");
1884 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1887 | SEC_LINKER_CREATED))
1888 || !bfd_set_section_alignment (abfd, s, 3))
1891 alpha_elf_tdata (abfd)->got = s;
1896 /* Create all the dynamic sections. */
1899 elf64_alpha_create_dynamic_sections (abfd, info)
1901 struct bfd_link_info *info;
1904 struct elf_link_hash_entry *h;
1906 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1908 s = bfd_make_section (abfd, ".plt");
1910 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1913 | SEC_LINKER_CREATED
1915 || ! bfd_set_section_alignment (abfd, s, 3))
1918 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1921 if (! (_bfd_generic_link_add_one_symbol
1922 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1923 (bfd_vma) 0, (const char *) NULL, false,
1924 get_elf_backend_data (abfd)->collect,
1925 (struct bfd_link_hash_entry **) &h)))
1927 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1928 h->type = STT_OBJECT;
1931 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1934 s = bfd_make_section (abfd, ".rela.plt");
1936 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1939 | SEC_LINKER_CREATED
1941 || ! bfd_set_section_alignment (abfd, s, 3))
1944 /* We may or may not have created a .got section for this object, but
1945 we definitely havn't done the rest of the work. */
1947 if (!elf64_alpha_create_got_section (abfd, info))
1950 s = bfd_make_section(abfd, ".rela.got");
1952 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1955 | SEC_LINKER_CREATED
1957 || !bfd_set_section_alignment (abfd, s, 3))
1960 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1961 dynobj's .got section. We don't do this in the linker script
1962 because we don't want to define the symbol if we are not creating
1963 a global offset table. */
1965 if (!(_bfd_generic_link_add_one_symbol
1966 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1967 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1968 false, get_elf_backend_data (abfd)->collect,
1969 (struct bfd_link_hash_entry **) &h)))
1971 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1972 h->type = STT_OBJECT;
1975 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1978 elf_hash_table (info)->hgot = h;
1983 /* Read ECOFF debugging information from a .mdebug section into a
1984 ecoff_debug_info structure. */
1987 elf64_alpha_read_ecoff_info (abfd, section, debug)
1990 struct ecoff_debug_info *debug;
1993 const struct ecoff_debug_swap *swap;
1994 char *ext_hdr = NULL;
1996 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1997 memset (debug, 0, sizeof (*debug));
1999 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
2000 if (ext_hdr == NULL && swap->external_hdr_size != 0)
2003 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
2004 swap->external_hdr_size)
2008 symhdr = &debug->symbolic_header;
2009 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
2011 /* The symbolic header contains absolute file offsets and sizes to
2013 #define READ(ptr, offset, count, size, type) \
2014 if (symhdr->count == 0) \
2015 debug->ptr = NULL; \
2018 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
2019 if (debug->ptr == NULL) \
2020 goto error_return; \
2021 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
2022 || (bfd_read (debug->ptr, size, symhdr->count, \
2023 abfd) != size * symhdr->count)) \
2024 goto error_return; \
2027 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
2028 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
2029 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
2030 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
2031 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2032 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2034 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2035 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2036 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2037 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2038 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2042 debug->adjust = NULL;
2047 if (ext_hdr != NULL)
2049 if (debug->line != NULL)
2051 if (debug->external_dnr != NULL)
2052 free (debug->external_dnr);
2053 if (debug->external_pdr != NULL)
2054 free (debug->external_pdr);
2055 if (debug->external_sym != NULL)
2056 free (debug->external_sym);
2057 if (debug->external_opt != NULL)
2058 free (debug->external_opt);
2059 if (debug->external_aux != NULL)
2060 free (debug->external_aux);
2061 if (debug->ss != NULL)
2063 if (debug->ssext != NULL)
2064 free (debug->ssext);
2065 if (debug->external_fdr != NULL)
2066 free (debug->external_fdr);
2067 if (debug->external_rfd != NULL)
2068 free (debug->external_rfd);
2069 if (debug->external_ext != NULL)
2070 free (debug->external_ext);
2074 /* Alpha ELF local labels start with '$'. */
2077 elf64_alpha_is_local_label_name (abfd, name)
2081 return name[0] == '$';
2084 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2085 routine in order to handle the ECOFF debugging information. We
2086 still call this mips_elf_find_line because of the slot
2087 find_line_info in elf_obj_tdata is declared that way. */
2089 struct mips_elf_find_line
2091 struct ecoff_debug_info d;
2092 struct ecoff_find_line i;
2096 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2097 functionname_ptr, line_ptr)
2102 const char **filename_ptr;
2103 const char **functionname_ptr;
2104 unsigned int *line_ptr;
2108 msec = bfd_get_section_by_name (abfd, ".mdebug");
2112 struct mips_elf_find_line *fi;
2113 const struct ecoff_debug_swap * const swap =
2114 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2116 /* If we are called during a link, alpha_elf_final_link may have
2117 cleared the SEC_HAS_CONTENTS field. We force it back on here
2118 if appropriate (which it normally will be). */
2119 origflags = msec->flags;
2120 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2121 msec->flags |= SEC_HAS_CONTENTS;
2123 fi = elf_tdata (abfd)->find_line_info;
2126 bfd_size_type external_fdr_size;
2129 struct fdr *fdr_ptr;
2131 fi = ((struct mips_elf_find_line *)
2132 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2135 msec->flags = origflags;
2139 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2141 msec->flags = origflags;
2145 /* Swap in the FDR information. */
2146 fi->d.fdr = ((struct fdr *)
2148 (fi->d.symbolic_header.ifdMax *
2149 sizeof (struct fdr))));
2150 if (fi->d.fdr == NULL)
2152 msec->flags = origflags;
2155 external_fdr_size = swap->external_fdr_size;
2156 fdr_ptr = fi->d.fdr;
2157 fraw_src = (char *) fi->d.external_fdr;
2158 fraw_end = (fraw_src
2159 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2160 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2161 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2163 elf_tdata (abfd)->find_line_info = fi;
2165 /* Note that we don't bother to ever free this information.
2166 find_nearest_line is either called all the time, as in
2167 objdump -l, so the information should be saved, or it is
2168 rarely called, as in ld error messages, so the memory
2169 wasted is unimportant. Still, it would probably be a
2170 good idea for free_cached_info to throw it away. */
2173 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2174 &fi->i, filename_ptr, functionname_ptr,
2177 msec->flags = origflags;
2181 msec->flags = origflags;
2184 /* Fall back on the generic ELF find_nearest_line routine. */
2186 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2187 filename_ptr, functionname_ptr,
2191 /* Structure used to pass information to alpha_elf_output_extsym. */
2196 struct bfd_link_info *info;
2197 struct ecoff_debug_info *debug;
2198 const struct ecoff_debug_swap *swap;
2203 elf64_alpha_output_extsym (h, data)
2204 struct alpha_elf_link_hash_entry *h;
2207 struct extsym_info *einfo = (struct extsym_info *) data;
2209 asection *sec, *output_section;
2211 if (h->root.indx == -2)
2213 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2214 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2215 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2216 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2218 else if (einfo->info->strip == strip_all
2219 || (einfo->info->strip == strip_some
2220 && bfd_hash_lookup (einfo->info->keep_hash,
2221 h->root.root.root.string,
2222 false, false) == NULL))
2230 if (h->esym.ifd == -2)
2233 h->esym.cobol_main = 0;
2234 h->esym.weakext = 0;
2235 h->esym.reserved = 0;
2236 h->esym.ifd = ifdNil;
2237 h->esym.asym.value = 0;
2238 h->esym.asym.st = stGlobal;
2240 if (h->root.root.type != bfd_link_hash_defined
2241 && h->root.root.type != bfd_link_hash_defweak)
2242 h->esym.asym.sc = scAbs;
2247 sec = h->root.root.u.def.section;
2248 output_section = sec->output_section;
2250 /* When making a shared library and symbol h is the one from
2251 the another shared library, OUTPUT_SECTION may be null. */
2252 if (output_section == NULL)
2253 h->esym.asym.sc = scUndefined;
2256 name = bfd_section_name (output_section->owner, output_section);
2258 if (strcmp (name, ".text") == 0)
2259 h->esym.asym.sc = scText;
2260 else if (strcmp (name, ".data") == 0)
2261 h->esym.asym.sc = scData;
2262 else if (strcmp (name, ".sdata") == 0)
2263 h->esym.asym.sc = scSData;
2264 else if (strcmp (name, ".rodata") == 0
2265 || strcmp (name, ".rdata") == 0)
2266 h->esym.asym.sc = scRData;
2267 else if (strcmp (name, ".bss") == 0)
2268 h->esym.asym.sc = scBss;
2269 else if (strcmp (name, ".sbss") == 0)
2270 h->esym.asym.sc = scSBss;
2271 else if (strcmp (name, ".init") == 0)
2272 h->esym.asym.sc = scInit;
2273 else if (strcmp (name, ".fini") == 0)
2274 h->esym.asym.sc = scFini;
2276 h->esym.asym.sc = scAbs;
2280 h->esym.asym.reserved = 0;
2281 h->esym.asym.index = indexNil;
2284 if (h->root.root.type == bfd_link_hash_common)
2285 h->esym.asym.value = h->root.root.u.c.size;
2286 else if (h->root.root.type == bfd_link_hash_defined
2287 || h->root.root.type == bfd_link_hash_defweak)
2289 if (h->esym.asym.sc == scCommon)
2290 h->esym.asym.sc = scBss;
2291 else if (h->esym.asym.sc == scSCommon)
2292 h->esym.asym.sc = scSBss;
2294 sec = h->root.root.u.def.section;
2295 output_section = sec->output_section;
2296 if (output_section != NULL)
2297 h->esym.asym.value = (h->root.root.u.def.value
2298 + sec->output_offset
2299 + output_section->vma);
2301 h->esym.asym.value = 0;
2303 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2305 /* Set type and value for a symbol with a function stub. */
2306 h->esym.asym.st = stProc;
2307 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2309 h->esym.asym.value = 0;
2312 output_section = sec->output_section;
2313 if (output_section != NULL)
2314 h->esym.asym.value = (h->root.plt.offset
2315 + sec->output_offset
2316 + output_section->vma);
2318 h->esym.asym.value = 0;
2325 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2326 h->root.root.root.string,
2329 einfo->failed = true;
2336 /* FIXME: Create a runtime procedure table from the .mdebug section.
2339 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2342 struct bfd_link_info *info;
2344 struct ecoff_debug_info *debug;
2347 /* Handle dynamic relocations when doing an Alpha ELF link. */
2350 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2352 struct bfd_link_info *info;
2354 const Elf_Internal_Rela *relocs;
2358 const char *rel_sec_name;
2359 Elf_Internal_Shdr *symtab_hdr;
2360 struct alpha_elf_link_hash_entry **sym_hashes;
2361 struct alpha_elf_got_entry **local_got_entries;
2362 const Elf_Internal_Rela *rel, *relend;
2365 if (info->relocateable)
2368 dynobj = elf_hash_table(info)->dynobj;
2370 elf_hash_table(info)->dynobj = dynobj = abfd;
2373 rel_sec_name = NULL;
2374 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2375 sym_hashes = alpha_elf_sym_hashes(abfd);
2376 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2379 relend = relocs + sec->reloc_count;
2380 for (rel = relocs; rel < relend; ++rel)
2382 unsigned long r_symndx, r_type;
2383 struct alpha_elf_link_hash_entry *h;
2385 r_symndx = ELF64_R_SYM (rel->r_info);
2386 if (r_symndx < symtab_hdr->sh_info)
2390 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2392 while (h->root.root.type == bfd_link_hash_indirect
2393 || h->root.root.type == bfd_link_hash_warning)
2394 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2396 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2398 r_type = ELF64_R_TYPE (rel->r_info);
2402 case R_ALPHA_LITERAL:
2404 struct alpha_elf_got_entry *gotent;
2409 /* Search for and possibly create a got entry. */
2410 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2411 if (gotent->gotobj == abfd &&
2412 gotent->addend == rel->r_addend)
2417 gotent = ((struct alpha_elf_got_entry *)
2419 sizeof (struct alpha_elf_got_entry)));
2423 gotent->gotobj = abfd;
2424 gotent->addend = rel->r_addend;
2425 gotent->got_offset = -1;
2427 gotent->use_count = 1;
2429 gotent->next = h->got_entries;
2430 h->got_entries = gotent;
2432 alpha_elf_tdata (abfd)->total_got_entries++;
2435 gotent->use_count += 1;
2439 /* This is a local .got entry -- record for merge. */
2440 if (!local_got_entries)
2443 size = (symtab_hdr->sh_info
2444 * sizeof (struct alpha_elf_got_entry *));
2446 local_got_entries = ((struct alpha_elf_got_entry **)
2447 bfd_alloc (abfd, size));
2448 if (!local_got_entries)
2451 memset (local_got_entries, 0, size);
2452 alpha_elf_tdata (abfd)->local_got_entries =
2456 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2457 gotent != NULL && gotent->addend != rel->r_addend;
2458 gotent = gotent->next)
2462 gotent = ((struct alpha_elf_got_entry *)
2464 sizeof (struct alpha_elf_got_entry)));
2468 gotent->gotobj = abfd;
2469 gotent->addend = rel->r_addend;
2470 gotent->got_offset = -1;
2472 gotent->use_count = 1;
2474 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2475 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2477 alpha_elf_tdata(abfd)->total_got_entries++;
2478 alpha_elf_tdata(abfd)->n_local_got_entries++;
2481 gotent->use_count += 1;
2484 /* Remember how this literal is used from its LITUSEs.
2485 This will be important when it comes to decide if we can
2486 create a .plt entry for a function symbol. */
2488 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2493 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2494 flags |= 1 << rel->r_addend;
2496 while (rel+1 < relend &&
2497 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2501 /* No LITUSEs -- presumably the address is not being
2502 loaded for nothing. */
2503 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2506 gotent->flags |= flags;
2509 /* Make a guess as to whether a .plt entry will be needed. */
2510 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2511 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2513 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2518 case R_ALPHA_GPDISP:
2519 case R_ALPHA_GPREL32:
2520 case R_ALPHA_GPRELHIGH:
2521 case R_ALPHA_GPRELLOW:
2522 /* We don't actually use the .got here, but the sections must
2523 be created before the linker maps input sections to output
2527 if (!elf64_alpha_create_got_section (abfd, info))
2530 /* Make sure the object's gotobj is set to itself so
2531 that we default to every object with its own .got.
2532 We'll merge .gots later once we've collected each
2534 alpha_elf_tdata(abfd)->gotobj = abfd;
2540 case R_ALPHA_SREL16:
2541 case R_ALPHA_SREL32:
2542 case R_ALPHA_SREL64:
2547 case R_ALPHA_REFLONG:
2548 case R_ALPHA_REFQUAD:
2549 if (rel_sec_name == NULL)
2551 rel_sec_name = (bfd_elf_string_from_elf_section
2552 (abfd, elf_elfheader(abfd)->e_shstrndx,
2553 elf_section_data(sec)->rel_hdr.sh_name));
2554 if (rel_sec_name == NULL)
2557 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2558 && strcmp (bfd_get_section_name (abfd, sec),
2559 rel_sec_name+5) == 0);
2562 /* We need to create the section here now whether we eventually
2563 use it or not so that it gets mapped to an output section by
2564 the linker. If not used, we'll kill it in
2565 size_dynamic_sections. */
2568 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2571 sreloc = bfd_make_section (dynobj, rel_sec_name);
2573 || !bfd_set_section_flags (dynobj, sreloc,
2574 ((sec->flags & (SEC_ALLOC
2578 | SEC_LINKER_CREATED
2580 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2587 /* Since we havn't seen all of the input symbols yet, we
2588 don't know whether we'll actually need a dynamic relocation
2589 entry for this reloc. So make a record of it. Once we
2590 find out if this thing needs dynamic relocation we'll
2591 expand the relocation sections by the appropriate amount. */
2593 struct alpha_elf_reloc_entry *rent;
2595 for (rent = h->reloc_entries; rent; rent = rent->next)
2596 if (rent->rtype == r_type && rent->srel == sreloc)
2601 rent = ((struct alpha_elf_reloc_entry *)
2603 sizeof (struct alpha_elf_reloc_entry)));
2607 rent->srel = sreloc;
2608 rent->rtype = r_type;
2611 rent->next = h->reloc_entries;
2612 h->reloc_entries = rent;
2617 else if (info->shared && (sec->flags & SEC_ALLOC))
2619 /* If this is a shared library, and the section is to be
2620 loaded into memory, we need a RELATIVE reloc. */
2621 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2630 /* Adjust a symbol defined by a dynamic object and referenced by a
2631 regular object. The current definition is in some section of the
2632 dynamic object, but we're not including those sections. We have to
2633 change the definition to something the rest of the link can
2637 elf64_alpha_adjust_dynamic_symbol (info, h)
2638 struct bfd_link_info *info;
2639 struct elf_link_hash_entry *h;
2643 struct alpha_elf_link_hash_entry *ah;
2645 dynobj = elf_hash_table(info)->dynobj;
2646 ah = (struct alpha_elf_link_hash_entry *)h;
2648 /* Now that we've seen all of the input symbols, finalize our decision
2649 about whether this symbol should get a .plt entry. */
2651 if (h->root.type != bfd_link_hash_undefweak
2652 && alpha_elf_dynamic_symbol_p (h, info)
2653 && ((h->type == STT_FUNC
2654 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2655 || (h->type == STT_NOTYPE
2656 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2657 /* Don't prevent otherwise valid programs from linking by attempting
2658 to create a new .got entry somewhere. A Correct Solution would be
2659 to add a new .got section to a new object file and let it be merged
2660 somewhere later. But for now don't bother. */
2663 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2665 s = bfd_get_section_by_name(dynobj, ".plt");
2666 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2669 /* The first bit of the .plt is reserved. */
2670 if (s->_raw_size == 0)
2671 s->_raw_size = PLT_HEADER_SIZE;
2673 h->plt.offset = s->_raw_size;
2674 s->_raw_size += PLT_ENTRY_SIZE;
2676 /* If this symbol is not defined in a regular file, and we are not
2677 generating a shared library, then set the symbol to the location
2678 in the .plt. This is required to make function pointers compare
2679 equal between the normal executable and the shared library. */
2681 && h->root.type != bfd_link_hash_defweak)
2683 h->root.u.def.section = s;
2684 h->root.u.def.value = h->plt.offset;
2687 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2688 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2689 BFD_ASSERT (s != NULL);
2690 s->_raw_size += sizeof (Elf64_External_Rela);
2695 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2697 /* If this is a weak symbol, and there is a real definition, the
2698 processor independent code will have arranged for us to see the
2699 real definition first, and we can just use the same value. */
2700 if (h->weakdef != NULL)
2702 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2703 || h->weakdef->root.type == bfd_link_hash_defweak);
2704 h->root.u.def.section = h->weakdef->root.u.def.section;
2705 h->root.u.def.value = h->weakdef->root.u.def.value;
2709 /* This is a reference to a symbol defined by a dynamic object which
2710 is not a function. The Alpha, since it uses .got entries for all
2711 symbols even in regular objects, does not need the hackery of a
2712 .dynbss section and COPY dynamic relocations. */
2717 /* Symbol versioning can create new symbols, and make our old symbols
2718 indirect to the new ones. Consolidate the got and reloc information
2719 in these situations. */
2722 elf64_alpha_merge_ind_symbols (hi, dummy)
2723 struct alpha_elf_link_hash_entry *hi;
2726 struct alpha_elf_link_hash_entry *hs;
2728 if (hi->root.root.type != bfd_link_hash_indirect)
2732 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2733 } while (hs->root.root.type == bfd_link_hash_indirect);
2735 /* Merge the flags. Whee. */
2737 hs->flags |= hi->flags;
2739 /* Merge the .got entries. Cannibalize the old symbol's list in
2740 doing so, since we don't need it anymore. */
2742 if (hs->got_entries == NULL)
2743 hs->got_entries = hi->got_entries;
2746 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2748 gsh = hs->got_entries;
2749 for (gi = hi->got_entries; gi ; gi = gin)
2752 for (gs = gsh; gs ; gs = gs->next)
2753 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2755 gi->next = hs->got_entries;
2756 hs->got_entries = gi;
2760 hi->got_entries = NULL;
2762 /* And similar for the reloc entries. */
2764 if (hs->reloc_entries == NULL)
2765 hs->reloc_entries = hi->reloc_entries;
2768 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2770 rsh = hs->reloc_entries;
2771 for (ri = hi->reloc_entries; ri ; ri = rin)
2774 for (rs = rsh; rs ; rs = rs->next)
2775 if (ri->rtype == rs->rtype)
2777 rs->count += ri->count;
2780 ri->next = hs->reloc_entries;
2781 hs->reloc_entries = ri;
2785 hi->reloc_entries = NULL;
2790 /* Is it possible to merge two object file's .got tables? */
2793 elf64_alpha_can_merge_gots (a, b)
2796 int total = alpha_elf_tdata (a)->total_got_entries;
2799 /* Trivial quick fallout test. */
2800 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2803 /* By their nature, local .got entries cannot be merged. */
2804 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2807 /* Failing the common trivial comparison, we must effectively
2808 perform the merge. Not actually performing the merge means that
2809 we don't have to store undo information in case we fail. */
2810 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2812 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2813 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2816 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2817 for (i = 0; i < n; ++i)
2819 struct alpha_elf_got_entry *ae, *be;
2820 struct alpha_elf_link_hash_entry *h;
2823 while (h->root.root.type == bfd_link_hash_indirect
2824 || h->root.root.type == bfd_link_hash_warning)
2825 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2827 for (be = h->got_entries; be ; be = be->next)
2829 if (be->use_count == 0)
2831 if (be->gotobj != b)
2834 for (ae = h->got_entries; ae ; ae = ae->next)
2835 if (ae->gotobj == a && ae->addend == be->addend)
2838 if (++total > MAX_GOT_ENTRIES)
2848 /* Actually merge two .got tables. */
2851 elf64_alpha_merge_gots (a, b)
2854 int total = alpha_elf_tdata (a)->total_got_entries;
2857 /* Remember local expansion. */
2859 int e = alpha_elf_tdata (b)->n_local_got_entries;
2861 alpha_elf_tdata (a)->n_local_got_entries += e;
2864 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2866 struct alpha_elf_got_entry **local_got_entries;
2867 struct alpha_elf_link_hash_entry **hashes;
2868 Elf_Internal_Shdr *symtab_hdr;
2871 /* Let the local .got entries know they are part of a new subsegment. */
2872 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2873 if (local_got_entries)
2875 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2876 for (i = 0; i < n; ++i)
2878 struct alpha_elf_got_entry *ent;
2879 for (ent = local_got_entries[i]; ent; ent = ent->next)
2884 /* Merge the global .got entries. */
2885 hashes = alpha_elf_sym_hashes (bsub);
2886 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2888 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2889 for (i = 0; i < n; ++i)
2891 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2892 struct alpha_elf_link_hash_entry *h;
2895 while (h->root.root.type == bfd_link_hash_indirect
2896 || h->root.root.type == bfd_link_hash_warning)
2897 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2899 start = &h->got_entries;
2900 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2902 if (be->use_count == 0)
2907 if (be->gotobj != b)
2910 for (ae = *start; ae ; ae = ae->next)
2911 if (ae->gotobj == a && ae->addend == be->addend)
2913 ae->flags |= be->flags;
2914 ae->use_count += be->use_count;
2925 alpha_elf_tdata (bsub)->gotobj = a;
2927 alpha_elf_tdata (a)->total_got_entries = total;
2929 /* Merge the two in_got chains. */
2934 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2937 alpha_elf_tdata (bsub)->in_got_link_next = b;
2941 /* Calculate the offsets for the got entries. */
2944 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2945 struct alpha_elf_link_hash_entry *h;
2948 struct alpha_elf_got_entry *gotent;
2950 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2951 if (gotent->use_count > 0)
2954 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2956 gotent->got_offset = *plge;
2964 elf64_alpha_calc_got_offsets (info)
2965 struct bfd_link_info *info;
2967 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2969 /* First, zero out the .got sizes, as we may be recalculating the
2970 .got after optimizing it. */
2971 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2972 alpha_elf_tdata(i)->got->_raw_size = 0;
2974 /* Next, fill in the offsets for all the global entries. */
2975 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2976 elf64_alpha_calc_got_offsets_for_symbol,
2979 /* Finally, fill in the offsets for the local entries. */
2980 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2982 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2985 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2987 struct alpha_elf_got_entry **local_got_entries, *gotent;
2990 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2991 if (!local_got_entries)
2994 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2995 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2996 if (gotent->use_count > 0)
2998 gotent->got_offset = got_offset;
3003 alpha_elf_tdata(i)->got->_raw_size = got_offset;
3004 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
3008 /* Constructs the gots. */
3011 elf64_alpha_size_got_sections (output_bfd, info)
3013 struct bfd_link_info *info;
3015 bfd *i, *got_list, *cur_got_obj;
3016 int something_changed = 0;
3018 got_list = alpha_elf_hash_table (info)->got_list;
3020 /* On the first time through, pretend we have an existing got list
3021 consisting of all of the input files. */
3022 if (got_list == NULL)
3024 for (i = info->input_bfds; i ; i = i->link_next)
3026 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3027 if (this_got == NULL)
3030 /* We are assuming no merging has yet ocurred. */
3031 BFD_ASSERT (this_got == i);
3033 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
3035 /* Yikes! A single object file has too many entries. */
3036 (*_bfd_error_handler)
3037 (_("%s: .got subsegment exceeds 64K (size %d)"),
3038 bfd_get_filename (i),
3039 alpha_elf_tdata (this_got)->total_got_entries * 8);
3043 if (got_list == NULL)
3044 got_list = this_got;
3046 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3047 cur_got_obj = this_got;
3050 /* Strange degenerate case of no got references. */
3051 if (got_list == NULL)
3054 alpha_elf_hash_table (info)->got_list = got_list;
3056 /* Force got offsets to be recalculated. */
3057 something_changed = 1;
3060 cur_got_obj = got_list;
3061 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3064 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3066 elf64_alpha_merge_gots (cur_got_obj, i);
3067 i = alpha_elf_tdata(i)->got_link_next;
3068 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3069 something_changed = 1;
3074 i = alpha_elf_tdata(i)->got_link_next;
3078 /* Once the gots have been merged, fill in the got offsets for
3079 everything therein. */
3080 if (1 || something_changed)
3081 elf64_alpha_calc_got_offsets (info);
3087 elf64_alpha_always_size_sections (output_bfd, info)
3089 struct bfd_link_info *info;
3093 if (info->relocateable)
3096 /* First, take care of the indirect symbols created by versioning. */
3097 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3098 elf64_alpha_merge_ind_symbols,
3101 if (!elf64_alpha_size_got_sections (output_bfd, info))
3104 /* Allocate space for all of the .got subsections. */
3105 i = alpha_elf_hash_table (info)->got_list;
3106 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3108 asection *s = alpha_elf_tdata(i)->got;
3109 if (s->_raw_size > 0)
3111 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3112 if (s->contents == NULL)
3120 /* Work out the sizes of the dynamic relocation entries. */
3123 elf64_alpha_calc_dynrel_sizes (h, info)
3124 struct alpha_elf_link_hash_entry *h;
3125 struct bfd_link_info *info;
3127 /* If the symbol was defined as a common symbol in a regular object
3128 file, and there was no definition in any dynamic object, then the
3129 linker will have allocated space for the symbol in a common
3130 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3131 set. This is done for dynamic symbols in
3132 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3133 symbols, somehow. */
3134 if (((h->root.elf_link_hash_flags
3135 & (ELF_LINK_HASH_DEF_REGULAR
3136 | ELF_LINK_HASH_REF_REGULAR
3137 | ELF_LINK_HASH_DEF_DYNAMIC))
3138 == ELF_LINK_HASH_REF_REGULAR)
3139 && (h->root.root.type == bfd_link_hash_defined
3140 || h->root.root.type == bfd_link_hash_defweak)
3141 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3143 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3146 /* If the symbol is dynamic, we'll need all the relocations in their
3147 natural form. If this is a shared object, and it has been forced
3148 local, we'll need the same number of RELATIVE relocations. */
3150 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3152 struct alpha_elf_reloc_entry *relent;
3154 struct alpha_elf_got_entry *gotent;
3155 bfd_size_type count;
3158 for (relent = h->reloc_entries; relent; relent = relent->next)
3159 if (relent->rtype == R_ALPHA_REFLONG
3160 || relent->rtype == R_ALPHA_REFQUAD)
3162 relent->srel->_raw_size +=
3163 sizeof (Elf64_External_Rela) * relent->count;
3166 dynobj = elf_hash_table(info)->dynobj;
3169 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3172 /* If we are using a .plt entry, subtract one, as the first
3173 reference uses a .rela.plt entry instead. */
3174 if (h->root.plt.offset != MINUS_ONE)
3179 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3180 BFD_ASSERT (srel != NULL);
3181 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3188 /* Set the sizes of the dynamic sections. */
3191 elf64_alpha_size_dynamic_sections (output_bfd, info)
3193 struct bfd_link_info *info;
3200 dynobj = elf_hash_table(info)->dynobj;
3201 BFD_ASSERT(dynobj != NULL);
3203 if (elf_hash_table (info)->dynamic_sections_created)
3205 /* Set the contents of the .interp section to the interpreter. */
3208 s = bfd_get_section_by_name (dynobj, ".interp");
3209 BFD_ASSERT (s != NULL);
3210 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3211 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3214 /* Now that we've seen all of the input files, we can decide which
3215 symbols need dynamic relocation entries and which don't. We've
3216 collected information in check_relocs that we can now apply to
3217 size the dynamic relocation sections. */
3218 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3219 elf64_alpha_calc_dynrel_sizes,
3222 /* When building shared libraries, each local .got entry needs a
3228 bfd_size_type count;
3230 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3231 BFD_ASSERT (srel != NULL);
3233 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3235 i = alpha_elf_tdata(i)->got_link_next)
3236 count += alpha_elf_tdata(i)->n_local_got_entries;
3238 srel->_raw_size += count * sizeof (Elf64_External_Rela);
3241 /* else we're not dynamic and by definition we don't need such things. */
3243 /* The check_relocs and adjust_dynamic_symbol entry points have
3244 determined the sizes of the various dynamic sections. Allocate
3248 for (s = dynobj->sections; s != NULL; s = s->next)
3253 if (!(s->flags & SEC_LINKER_CREATED))
3256 /* It's OK to base decisions on the section name, because none
3257 of the dynobj section names depend upon the input files. */
3258 name = bfd_get_section_name (dynobj, s);
3260 /* If we don't need this section, strip it from the output file.
3261 This is to handle .rela.bss and .rela.plt. We must create it
3262 in create_dynamic_sections, because it must be created before
3263 the linker maps input sections to output sections. The
3264 linker does that before adjust_dynamic_symbol is called, and
3265 it is that function which decides whether anything needs to
3266 go into these sections. */
3270 if (strncmp (name, ".rela", 5) == 0)
3272 strip = (s->_raw_size == 0);
3276 const char *outname;
3279 /* If this relocation section applies to a read only
3280 section, then we probably need a DT_TEXTREL entry. */
3281 outname = bfd_get_section_name (output_bfd,
3283 target = bfd_get_section_by_name (output_bfd, outname + 5);
3285 && (target->flags & SEC_READONLY) != 0
3286 && (target->flags & SEC_ALLOC) != 0)
3289 if (strcmp(name, ".rela.plt") == 0)
3292 /* We use the reloc_count field as a counter if we need
3293 to copy relocs into the output file. */
3297 else if (strcmp (name, ".plt") != 0)
3299 /* It's not one of our dynamic sections, so don't allocate space. */
3304 _bfd_strip_section_from_output (info, s);
3307 /* Allocate memory for the section contents. */
3308 s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3309 if (s->contents == NULL && s->_raw_size != 0)
3314 if (elf_hash_table (info)->dynamic_sections_created)
3316 /* Add some entries to the .dynamic section. We fill in the
3317 values later, in elf64_alpha_finish_dynamic_sections, but we
3318 must add the entries now so that we get the correct size for
3319 the .dynamic section. The DT_DEBUG entry is filled in by the
3320 dynamic linker and used by the debugger. */
3323 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3327 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3332 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3333 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3334 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3338 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3339 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3340 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3341 sizeof (Elf64_External_Rela)))
3346 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3348 info->flags |= DF_TEXTREL;
3355 /* Relocate an Alpha ELF section. */
3358 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3359 contents, relocs, local_syms, local_sections)
3361 struct bfd_link_info *info;
3363 asection *input_section;
3365 Elf_Internal_Rela *relocs;
3366 Elf_Internal_Sym *local_syms;
3367 asection **local_sections;
3369 Elf_Internal_Shdr *symtab_hdr;
3370 Elf_Internal_Rela *rel;
3371 Elf_Internal_Rela *relend;
3372 asection *sec, *sgot, *srel, *srelgot;
3373 bfd *dynobj, *gotobj;
3376 srelgot = srel = NULL;
3377 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3378 dynobj = elf_hash_table (info)->dynobj;
3381 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3384 /* Find the gp value for this input bfd. */
3387 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3390 sgot = alpha_elf_tdata (gotobj)->got;
3391 gp = _bfd_get_gp_value (gotobj);
3394 gp = (sgot->output_section->vma
3395 + sgot->output_offset
3397 _bfd_set_gp_value (gotobj, gp);
3402 relend = relocs + input_section->reloc_count;
3403 for (; rel < relend; rel++)
3406 reloc_howto_type *howto;
3407 unsigned long r_symndx;
3408 struct alpha_elf_link_hash_entry *h;
3409 Elf_Internal_Sym *sym;
3412 bfd_reloc_status_type r;
3414 r_type = ELF64_R_TYPE(rel->r_info);
3415 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3417 bfd_set_error (bfd_error_bad_value);
3420 howto = elf64_alpha_howto_table + r_type;
3422 r_symndx = ELF64_R_SYM(rel->r_info);
3424 if (info->relocateable)
3426 /* This is a relocateable link. We don't have to change
3427 anything, unless the reloc is against a section symbol,
3428 in which case we have to adjust according to where the
3429 section symbol winds up in the output section. */
3431 /* The symbol associated with GPDISP and LITUSE is
3432 immaterial. Only the addend is significant. */
3433 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3436 if (r_symndx < symtab_hdr->sh_info)
3438 sym = local_syms + r_symndx;
3439 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3441 sec = local_sections[r_symndx];
3442 rel->r_addend += sec->output_offset + sym->st_value;
3449 /* This is a final link. */
3455 if (r_symndx < symtab_hdr->sh_info)
3457 sym = local_syms + r_symndx;
3458 sec = local_sections[r_symndx];
3459 relocation = (sec->output_section->vma
3460 + sec->output_offset
3465 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3467 while (h->root.root.type == bfd_link_hash_indirect
3468 || h->root.root.type == bfd_link_hash_warning)
3469 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3471 if (h->root.root.type == bfd_link_hash_defined
3472 || h->root.root.type == bfd_link_hash_defweak)
3474 sec = h->root.root.u.def.section;
3477 if ((r_type == R_ALPHA_LITERAL
3478 && elf_hash_table(info)->dynamic_sections_created
3481 || !(h->root.elf_link_hash_flags
3482 & ELF_LINK_HASH_DEF_REGULAR)))
3485 || !(h->root.elf_link_hash_flags
3486 & ELF_LINK_HASH_DEF_REGULAR))
3487 && (input_section->flags & SEC_ALLOC)
3488 && (r_type == R_ALPHA_REFLONG
3489 || r_type == R_ALPHA_REFQUAD
3490 || r_type == R_ALPHA_LITERAL)))
3492 /* In these cases, we don't need the relocation value.
3493 We check specially because in some obscure cases
3494 sec->output_section will be NULL. */
3498 /* FIXME: Are not these obscure cases simply bugs? Let's
3499 get something working and come back to this. */
3500 if (sec->output_section == NULL)
3502 #endif /* rth_notdef */
3505 relocation = (h->root.root.u.def.value
3506 + sec->output_section->vma
3507 + sec->output_offset);
3510 else if (h->root.root.type == bfd_link_hash_undefweak)
3512 else if (info->shared && !info->symbolic
3513 && !info->no_undefined
3514 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3518 if (!((*info->callbacks->undefined_symbol)
3519 (info, h->root.root.root.string, input_bfd,
3520 input_section, rel->r_offset,
3521 (!info->shared || info->no_undefined
3522 || ELF_ST_VISIBILITY (h->root.other)))))
3527 addend = rel->r_addend;
3531 case R_ALPHA_GPDISP:
3533 bfd_byte *p_ldah, *p_lda;
3535 BFD_ASSERT(gp != 0);
3537 relocation = (input_section->output_section->vma
3538 + input_section->output_offset
3541 p_ldah = contents + rel->r_offset - input_section->vma;
3542 p_lda = p_ldah + rel->r_addend;
3544 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3549 case R_ALPHA_OP_PUSH:
3550 case R_ALPHA_OP_STORE:
3551 case R_ALPHA_OP_PSUB:
3552 case R_ALPHA_OP_PRSHIFT:
3553 /* We hate these silly beasts. */
3556 case R_ALPHA_LITERAL:
3558 struct alpha_elf_got_entry *gotent;
3559 boolean dynamic_symbol;
3561 BFD_ASSERT(sgot != NULL);
3562 BFD_ASSERT(gp != 0);
3566 gotent = h->got_entries;
3567 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3571 gotent = (alpha_elf_tdata(input_bfd)->
3572 local_got_entries[r_symndx]);
3573 dynamic_symbol = false;
3576 BFD_ASSERT(gotent != NULL);
3578 while (gotent->gotobj != gotobj || gotent->addend != addend)
3579 gotent = gotent->next;
3581 BFD_ASSERT(gotent->use_count >= 1);
3583 /* Initialize the .got entry's value. */
3584 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3586 bfd_put_64 (output_bfd, relocation+addend,
3587 sgot->contents + gotent->got_offset);
3589 /* If the symbol has been forced local, output a
3590 RELATIVE reloc, otherwise it will be handled in
3591 finish_dynamic_symbol. */
3592 if (info->shared && !dynamic_symbol)
3594 Elf_Internal_Rela outrel;
3596 BFD_ASSERT(srelgot != NULL);
3598 outrel.r_offset = (sgot->output_section->vma
3599 + sgot->output_offset
3600 + gotent->got_offset);
3601 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3602 outrel.r_addend = 0;
3604 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3605 ((Elf64_External_Rela *)
3607 + srelgot->reloc_count++);
3608 BFD_ASSERT (sizeof (Elf64_External_Rela)
3609 * srelgot->reloc_count
3610 <= srelgot->_cooked_size);
3613 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3616 /* Figure the gprel relocation. */
3618 relocation = (sgot->output_section->vma
3619 + sgot->output_offset
3620 + gotent->got_offset);
3623 /* overflow handled by _bfd_final_link_relocate */
3626 case R_ALPHA_GPREL32:
3627 case R_ALPHA_GPRELLOW:
3628 BFD_ASSERT(gp != 0);
3632 case R_ALPHA_GPRELHIGH:
3633 BFD_ASSERT(gp != 0);
3635 relocation += addend;
3637 relocation = (((bfd_signed_vma) relocation >> 16)
3638 + ((relocation >> 15) & 1));
3641 case R_ALPHA_BRADDR:
3643 /* The regular PC-relative stuff measures from the start of
3644 the instruction rather than the end. */
3648 case R_ALPHA_REFLONG:
3649 case R_ALPHA_REFQUAD:
3651 Elf_Internal_Rela outrel;
3654 /* Careful here to remember RELATIVE relocations for global
3655 variables for symbolic shared objects. */
3657 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3659 BFD_ASSERT(h->root.dynindx != -1);
3660 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3661 outrel.r_addend = addend;
3662 addend = 0, relocation = 0;
3664 else if (info->shared && (input_section->flags & SEC_ALLOC))
3666 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3667 outrel.r_addend = 0;
3676 name = (bfd_elf_string_from_elf_section
3677 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3678 elf_section_data(input_section)->rel_hdr.sh_name));
3679 BFD_ASSERT(name != NULL);
3681 srel = bfd_get_section_by_name (dynobj, name);
3682 BFD_ASSERT(srel != NULL);
3687 if (elf_section_data (input_section)->stab_info == NULL)
3688 outrel.r_offset = rel->r_offset;
3693 off = (_bfd_stab_section_offset
3694 (output_bfd, &elf_hash_table (info)->stab_info,
3696 &elf_section_data (input_section)->stab_info,
3698 if (off == (bfd_vma) -1)
3700 outrel.r_offset = off;
3704 outrel.r_offset += (input_section->output_section->vma
3705 + input_section->output_offset);
3707 memset (&outrel, 0, sizeof outrel);
3709 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3710 ((Elf64_External_Rela *)
3712 + srel->reloc_count++);
3713 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3714 <= srel->_cooked_size);
3720 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3721 contents, rel->r_offset, relocation,
3731 case bfd_reloc_overflow:
3736 name = h->root.root.root.string;
3739 name = (bfd_elf_string_from_elf_section
3740 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3744 name = bfd_section_name (input_bfd, sec);
3746 if (! ((*info->callbacks->reloc_overflow)
3747 (info, name, howto->name, (bfd_vma) 0,
3748 input_bfd, input_section, rel->r_offset)))
3754 case bfd_reloc_outofrange:
3762 /* Finish up dynamic symbol handling. We set the contents of various
3763 dynamic sections here. */
3766 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3768 struct bfd_link_info *info;
3769 struct elf_link_hash_entry *h;
3770 Elf_Internal_Sym *sym;
3772 bfd *dynobj = elf_hash_table(info)->dynobj;
3774 if (h->plt.offset != MINUS_ONE)
3776 /* Fill in the .plt entry for this symbol. */
3777 asection *splt, *sgot, *srel;
3778 Elf_Internal_Rela outrel;
3779 bfd_vma got_addr, plt_addr;
3781 struct alpha_elf_got_entry *gotent;
3783 BFD_ASSERT (h->dynindx != -1);
3785 /* The first .got entry will be updated by the .plt with the
3786 address of the target function. */
3787 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3788 BFD_ASSERT (gotent && gotent->addend == 0);
3790 splt = bfd_get_section_by_name (dynobj, ".plt");
3791 BFD_ASSERT (splt != NULL);
3792 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3793 BFD_ASSERT (srel != NULL);
3794 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3795 BFD_ASSERT (sgot != NULL);
3797 got_addr = (sgot->output_section->vma
3798 + sgot->output_offset
3799 + gotent->got_offset);
3800 plt_addr = (splt->output_section->vma
3801 + splt->output_offset
3804 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3806 /* Fill in the entry in the procedure linkage table. */
3808 unsigned insn1, insn2, insn3;
3810 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3811 insn2 = PLT_ENTRY_WORD2;
3812 insn3 = PLT_ENTRY_WORD3;
3814 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3815 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3816 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3819 /* Fill in the entry in the .rela.plt section. */
3820 outrel.r_offset = got_addr;
3821 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3822 outrel.r_addend = 0;
3824 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3825 ((Elf64_External_Rela *)srel->contents
3828 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3830 /* Mark the symbol as undefined, rather than as defined in the
3831 .plt section. Leave the value alone. */
3832 sym->st_shndx = SHN_UNDEF;
3835 /* Fill in the entries in the .got. */
3836 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3838 /* Subsequent .got entries will continue to bounce through the .plt. */
3841 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3842 BFD_ASSERT (! info->shared || srel != NULL);
3844 gotent = gotent->next;
3847 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3848 BFD_ASSERT(sgot != NULL);
3849 BFD_ASSERT(gotent->addend == 0);
3851 bfd_put_64 (output_bfd, plt_addr,
3852 sgot->contents + gotent->got_offset);
3856 outrel.r_offset = (sgot->output_section->vma
3857 + sgot->output_offset
3858 + gotent->got_offset);
3859 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3860 outrel.r_addend = 0;
3862 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3863 ((Elf64_External_Rela *)
3865 + srel->reloc_count++);
3866 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3867 <= srel->_cooked_size);
3870 gotent = gotent->next;
3872 while (gotent != NULL);
3875 else if (alpha_elf_dynamic_symbol_p (h, info))
3877 /* Fill in the dynamic relocations for this symbol's .got entries. */
3879 Elf_Internal_Rela outrel;
3880 struct alpha_elf_got_entry *gotent;
3882 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3883 BFD_ASSERT (srel != NULL);
3885 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3886 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3888 gotent = gotent->next)
3890 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3891 outrel.r_offset = (sgot->output_section->vma
3892 + sgot->output_offset
3893 + gotent->got_offset);
3894 outrel.r_addend = gotent->addend;
3896 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3897 ((Elf64_External_Rela *)srel->contents
3898 + srel->reloc_count++));
3899 BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count
3900 <= srel->_cooked_size);
3904 /* Mark some specially defined symbols as absolute. */
3905 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3906 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3907 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3908 sym->st_shndx = SHN_ABS;
3913 /* Finish up the dynamic sections. */
3916 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3918 struct bfd_link_info *info;
3923 dynobj = elf_hash_table (info)->dynobj;
3924 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3926 if (elf_hash_table (info)->dynamic_sections_created)
3929 Elf64_External_Dyn *dyncon, *dynconend;
3931 splt = bfd_get_section_by_name (dynobj, ".plt");
3932 BFD_ASSERT (splt != NULL && sdyn != NULL);
3934 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3935 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3936 for (; dyncon < dynconend; dyncon++)
3938 Elf_Internal_Dyn dyn;
3942 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3957 /* My interpretation of the TIS v1.1 ELF document indicates
3958 that RELASZ should not include JMPREL. This is not what
3959 the rest of the BFD does. It is, however, what the
3960 glibc ld.so wants. Do this fixup here until we found
3961 out who is right. */
3962 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3966 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3971 s = bfd_get_section_by_name (output_bfd, name);
3972 dyn.d_un.d_ptr = (s ? s->vma : 0);
3976 s = bfd_get_section_by_name (output_bfd, name);
3978 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3982 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3985 /* Initialize the PLT0 entry */
3986 if (splt->_raw_size > 0)
3988 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3989 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3990 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3991 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3993 /* The next two words will be filled in by ld.so */
3994 bfd_put_64 (output_bfd, 0, splt->contents + 16);
3995 bfd_put_64 (output_bfd, 0, splt->contents + 24);
3997 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
4005 /* We need to use a special link routine to handle the .reginfo and
4006 the .mdebug sections. We need to merge all instances of these
4007 sections together, not write them all out sequentially. */
4010 elf64_alpha_final_link (abfd, info)
4012 struct bfd_link_info *info;
4015 struct bfd_link_order *p;
4016 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
4017 struct ecoff_debug_info debug;
4018 const struct ecoff_debug_swap *swap
4019 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
4020 HDRR *symhdr = &debug.symbolic_header;
4021 PTR mdebug_handle = NULL;
4026 (*info->callbacks->warning)
4027 (info, _("using multiple gp values"), (char *) NULL,
4028 output_bfd, (asection *) NULL, (bfd_vma) 0);
4032 /* Go through the sections and collect the .reginfo and .mdebug
4036 gptab_data_sec = NULL;
4037 gptab_bss_sec = NULL;
4038 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4040 #ifdef ERIC_neverdef
4041 if (strcmp (o->name, ".reginfo") == 0)
4043 memset (®info, 0, sizeof reginfo);
4045 /* We have found the .reginfo section in the output file.
4046 Look through all the link_orders comprising it and merge
4047 the information together. */
4048 for (p = o->link_order_head;
4049 p != (struct bfd_link_order *) NULL;
4052 asection *input_section;
4054 Elf64_External_RegInfo ext;
4057 if (p->type != bfd_indirect_link_order)
4059 if (p->type == bfd_fill_link_order)
4064 input_section = p->u.indirect.section;
4065 input_bfd = input_section->owner;
4067 /* The linker emulation code has probably clobbered the
4068 size to be zero bytes. */
4069 if (input_section->_raw_size == 0)
4070 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4072 if (! bfd_get_section_contents (input_bfd, input_section,
4078 bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4080 reginfo.ri_gprmask |= sub.ri_gprmask;
4081 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4082 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4083 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4084 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4086 /* ri_gp_value is set by the function
4087 alpha_elf_section_processing when the section is
4088 finally written out. */
4090 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4091 elf_link_input_bfd ignores this section. */
4092 input_section->flags &=~ SEC_HAS_CONTENTS;
4095 /* Force the section size to the value we want. */
4096 o->_raw_size = sizeof (Elf64_External_RegInfo);
4098 /* Skip this section later on (I don't think this currently
4099 matters, but someday it might). */
4100 o->link_order_head = (struct bfd_link_order *) NULL;
4106 if (strcmp (o->name, ".mdebug") == 0)
4108 struct extsym_info einfo;
4110 /* We have found the .mdebug section in the output file.
4111 Look through all the link_orders comprising it and merge
4112 the information together. */
4113 symhdr->magic = swap->sym_magic;
4114 /* FIXME: What should the version stamp be? */
4116 symhdr->ilineMax = 0;
4120 symhdr->isymMax = 0;
4121 symhdr->ioptMax = 0;
4122 symhdr->iauxMax = 0;
4124 symhdr->issExtMax = 0;
4127 symhdr->iextMax = 0;
4129 /* We accumulate the debugging information itself in the
4130 debug_info structure. */
4132 debug.external_dnr = NULL;
4133 debug.external_pdr = NULL;
4134 debug.external_sym = NULL;
4135 debug.external_opt = NULL;
4136 debug.external_aux = NULL;
4138 debug.ssext = debug.ssext_end = NULL;
4139 debug.external_fdr = NULL;
4140 debug.external_rfd = NULL;
4141 debug.external_ext = debug.external_ext_end = NULL;
4143 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4144 if (mdebug_handle == (PTR) NULL)
4153 static const char * const name[] =
4155 ".text", ".init", ".fini", ".data",
4156 ".rodata", ".sdata", ".sbss", ".bss"
4158 static const int sc[] = { scText, scInit, scFini, scData,
4159 scRData, scSData, scSBss, scBss };
4162 esym.cobol_main = 0;
4166 esym.asym.iss = issNil;
4167 esym.asym.st = stLocal;
4168 esym.asym.reserved = 0;
4169 esym.asym.index = indexNil;
4170 for (i = 0; i < 8; i++)
4172 esym.asym.sc = sc[i];
4173 s = bfd_get_section_by_name (abfd, name[i]);
4176 esym.asym.value = s->vma;
4177 last = s->vma + s->_raw_size;
4180 esym.asym.value = last;
4182 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4188 for (p = o->link_order_head;
4189 p != (struct bfd_link_order *) NULL;
4192 asection *input_section;
4194 const struct ecoff_debug_swap *input_swap;
4195 struct ecoff_debug_info input_debug;
4199 if (p->type != bfd_indirect_link_order)
4201 if (p->type == bfd_fill_link_order)
4206 input_section = p->u.indirect.section;
4207 input_bfd = input_section->owner;
4209 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4210 || (get_elf_backend_data (input_bfd)
4211 ->elf_backend_ecoff_debug_swap) == NULL)
4213 /* I don't know what a non ALPHA ELF bfd would be
4214 doing with a .mdebug section, but I don't really
4215 want to deal with it. */
4219 input_swap = (get_elf_backend_data (input_bfd)
4220 ->elf_backend_ecoff_debug_swap);
4222 BFD_ASSERT (p->size == input_section->_raw_size);
4224 /* The ECOFF linking code expects that we have already
4225 read in the debugging information and set up an
4226 ecoff_debug_info structure, so we do that now. */
4227 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4231 if (! (bfd_ecoff_debug_accumulate
4232 (mdebug_handle, abfd, &debug, swap, input_bfd,
4233 &input_debug, input_swap, info)))
4236 /* Loop through the external symbols. For each one with
4237 interesting information, try to find the symbol in
4238 the linker global hash table and save the information
4239 for the output external symbols. */
4240 eraw_src = input_debug.external_ext;
4241 eraw_end = (eraw_src
4242 + (input_debug.symbolic_header.iextMax
4243 * input_swap->external_ext_size));
4245 eraw_src < eraw_end;
4246 eraw_src += input_swap->external_ext_size)
4250 struct alpha_elf_link_hash_entry *h;
4252 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4253 if (ext.asym.sc == scNil
4254 || ext.asym.sc == scUndefined
4255 || ext.asym.sc == scSUndefined)
4258 name = input_debug.ssext + ext.asym.iss;
4259 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4260 name, false, false, true);
4261 if (h == NULL || h->esym.ifd != -2)
4267 < input_debug.symbolic_header.ifdMax);
4268 ext.ifd = input_debug.ifdmap[ext.ifd];
4274 /* Free up the information we just read. */
4275 free (input_debug.line);
4276 free (input_debug.external_dnr);
4277 free (input_debug.external_pdr);
4278 free (input_debug.external_sym);
4279 free (input_debug.external_opt);
4280 free (input_debug.external_aux);
4281 free (input_debug.ss);
4282 free (input_debug.ssext);
4283 free (input_debug.external_fdr);
4284 free (input_debug.external_rfd);
4285 free (input_debug.external_ext);
4287 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4288 elf_link_input_bfd ignores this section. */
4289 input_section->flags &=~ SEC_HAS_CONTENTS;
4292 #ifdef ERIC_neverdef
4295 /* Create .rtproc section. */
4296 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4297 if (rtproc_sec == NULL)
4299 flagword flags = (SEC_HAS_CONTENTS
4301 | SEC_LINKER_CREATED
4304 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4305 if (rtproc_sec == NULL
4306 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4307 || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4311 if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4312 info, rtproc_sec, &debug))
4317 /* Build the external symbol information. */
4320 einfo.debug = &debug;
4322 einfo.failed = false;
4323 elf_link_hash_traverse (elf_hash_table (info),
4324 elf64_alpha_output_extsym,
4329 /* Set the size of the .mdebug section. */
4330 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4332 /* Skip this section later on (I don't think this currently
4333 matters, but someday it might). */
4334 o->link_order_head = (struct bfd_link_order *) NULL;
4339 #ifdef ERIC_neverdef
4340 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4342 const char *subname;
4345 Elf64_External_gptab *ext_tab;
4348 /* The .gptab.sdata and .gptab.sbss sections hold
4349 information describing how the small data area would
4350 change depending upon the -G switch. These sections
4351 not used in executables files. */
4352 if (! info->relocateable)
4356 for (p = o->link_order_head;
4357 p != (struct bfd_link_order *) NULL;
4360 asection *input_section;
4362 if (p->type != bfd_indirect_link_order)
4364 if (p->type == bfd_fill_link_order)
4369 input_section = p->u.indirect.section;
4371 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4372 elf_link_input_bfd ignores this section. */
4373 input_section->flags &=~ SEC_HAS_CONTENTS;
4376 /* Skip this section later on (I don't think this
4377 currently matters, but someday it might). */
4378 o->link_order_head = (struct bfd_link_order *) NULL;
4380 /* Really remove the section. */
4381 for (secpp = &abfd->sections;
4383 secpp = &(*secpp)->next)
4385 *secpp = (*secpp)->next;
4386 --abfd->section_count;
4391 /* There is one gptab for initialized data, and one for
4392 uninitialized data. */
4393 if (strcmp (o->name, ".gptab.sdata") == 0)
4395 else if (strcmp (o->name, ".gptab.sbss") == 0)
4399 (*_bfd_error_handler)
4400 (_("%s: illegal section name `%s'"),
4401 bfd_get_filename (abfd), o->name);
4402 bfd_set_error (bfd_error_nonrepresentable_section);
4406 /* The linker script always combines .gptab.data and
4407 .gptab.sdata into .gptab.sdata, and likewise for
4408 .gptab.bss and .gptab.sbss. It is possible that there is
4409 no .sdata or .sbss section in the output file, in which
4410 case we must change the name of the output section. */
4411 subname = o->name + sizeof ".gptab" - 1;
4412 if (bfd_get_section_by_name (abfd, subname) == NULL)
4414 if (o == gptab_data_sec)
4415 o->name = ".gptab.data";
4417 o->name = ".gptab.bss";
4418 subname = o->name + sizeof ".gptab" - 1;
4419 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4422 /* Set up the first entry. */
4424 tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4427 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4428 tab[0].gt_header.gt_unused = 0;
4430 /* Combine the input sections. */
4431 for (p = o->link_order_head;
4432 p != (struct bfd_link_order *) NULL;
4435 asection *input_section;
4439 bfd_size_type gpentry;
4441 if (p->type != bfd_indirect_link_order)
4443 if (p->type == bfd_fill_link_order)
4448 input_section = p->u.indirect.section;
4449 input_bfd = input_section->owner;
4451 /* Combine the gptab entries for this input section one
4452 by one. We know that the input gptab entries are
4453 sorted by ascending -G value. */
4454 size = bfd_section_size (input_bfd, input_section);
4456 for (gpentry = sizeof (Elf64_External_gptab);
4458 gpentry += sizeof (Elf64_External_gptab))
4460 Elf64_External_gptab ext_gptab;
4461 Elf64_gptab int_gptab;
4467 if (! (bfd_get_section_contents
4468 (input_bfd, input_section, (PTR) &ext_gptab,
4469 gpentry, sizeof (Elf64_External_gptab))))
4475 bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4477 val = int_gptab.gt_entry.gt_g_value;
4478 add = int_gptab.gt_entry.gt_bytes - last;
4481 for (look = 1; look < c; look++)
4483 if (tab[look].gt_entry.gt_g_value >= val)
4484 tab[look].gt_entry.gt_bytes += add;
4486 if (tab[look].gt_entry.gt_g_value == val)
4492 Elf64_gptab *new_tab;
4495 /* We need a new table entry. */
4496 new_tab = ((Elf64_gptab *)
4497 bfd_realloc ((PTR) tab,
4498 (c + 1) * sizeof (Elf64_gptab)));
4499 if (new_tab == NULL)
4505 tab[c].gt_entry.gt_g_value = val;
4506 tab[c].gt_entry.gt_bytes = add;
4508 /* Merge in the size for the next smallest -G
4509 value, since that will be implied by this new
4512 for (look = 1; look < c; look++)
4514 if (tab[look].gt_entry.gt_g_value < val
4516 || (tab[look].gt_entry.gt_g_value
4517 > tab[max].gt_entry.gt_g_value)))
4521 tab[c].gt_entry.gt_bytes +=
4522 tab[max].gt_entry.gt_bytes;
4527 last = int_gptab.gt_entry.gt_bytes;
4530 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4531 elf_link_input_bfd ignores this section. */
4532 input_section->flags &=~ SEC_HAS_CONTENTS;
4535 /* The table must be sorted by -G value. */
4537 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4539 /* Swap out the table. */
4540 ext_tab = ((Elf64_External_gptab *)
4541 bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4542 if (ext_tab == NULL)
4548 for (i = 0; i < c; i++)
4549 bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4552 o->_raw_size = c * sizeof (Elf64_External_gptab);
4553 o->contents = (bfd_byte *) ext_tab;
4555 /* Skip this section later on (I don't think this currently
4556 matters, but someday it might). */
4557 o->link_order_head = (struct bfd_link_order *) NULL;
4563 /* Invoke the regular ELF backend linker to do all the work. */
4564 if (! bfd_elf64_bfd_final_link (abfd, info))
4567 /* Now write out the computed sections. */
4569 /* The .got subsections... */
4571 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4572 for (i = alpha_elf_hash_table(info)->got_list;
4574 i = alpha_elf_tdata(i)->got_link_next)
4578 /* elf_bfd_final_link already did everything in dynobj. */
4582 sgot = alpha_elf_tdata(i)->got;
4583 if (! bfd_set_section_contents (abfd, sgot->output_section,
4584 sgot->contents, sgot->output_offset,
4590 #ifdef ERIC_neverdef
4591 if (reginfo_sec != (asection *) NULL)
4593 Elf64_External_RegInfo ext;
4595 bfd_alpha_elf64_swap_reginfo_out (abfd, ®info, &ext);
4596 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4597 (file_ptr) 0, sizeof ext))
4602 if (mdebug_sec != (asection *) NULL)
4604 BFD_ASSERT (abfd->output_has_begun);
4605 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4607 mdebug_sec->filepos))
4610 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4613 if (gptab_data_sec != (asection *) NULL)
4615 if (! bfd_set_section_contents (abfd, gptab_data_sec,
4616 gptab_data_sec->contents,
4618 gptab_data_sec->_raw_size))
4622 if (gptab_bss_sec != (asection *) NULL)
4624 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4625 gptab_bss_sec->contents,
4627 gptab_bss_sec->_raw_size))
4634 /* ECOFF swapping routines. These are used when dealing with the
4635 .mdebug section, which is in the ECOFF debugging format. Copied
4636 from elf32-mips.c. */
4637 static const struct ecoff_debug_swap
4638 elf64_alpha_ecoff_debug_swap =
4640 /* Symbol table magic number. */
4642 /* Alignment of debugging information. E.g., 4. */
4644 /* Sizes of external symbolic information. */
4645 sizeof (struct hdr_ext),
4646 sizeof (struct dnr_ext),
4647 sizeof (struct pdr_ext),
4648 sizeof (struct sym_ext),
4649 sizeof (struct opt_ext),
4650 sizeof (struct fdr_ext),
4651 sizeof (struct rfd_ext),
4652 sizeof (struct ext_ext),
4653 /* Functions to swap in external symbolic data. */
4662 _bfd_ecoff_swap_tir_in,
4663 _bfd_ecoff_swap_rndx_in,
4664 /* Functions to swap out external symbolic data. */
4673 _bfd_ecoff_swap_tir_out,
4674 _bfd_ecoff_swap_rndx_out,
4675 /* Function to read in symbolic data. */
4676 elf64_alpha_read_ecoff_info
4679 /* Use a non-standard hash bucket size of 8. */
4681 const struct elf_size_info alpha_elf_size_info =
4683 sizeof (Elf64_External_Ehdr),
4684 sizeof (Elf64_External_Phdr),
4685 sizeof (Elf64_External_Shdr),
4686 sizeof (Elf64_External_Rel),
4687 sizeof (Elf64_External_Rela),
4688 sizeof (Elf64_External_Sym),
4689 sizeof (Elf64_External_Dyn),
4690 sizeof (Elf_External_Note),
4694 ELFCLASS64, EV_CURRENT,
4695 bfd_elf64_write_out_phdrs,
4696 bfd_elf64_write_shdrs_and_ehdr,
4697 bfd_elf64_write_relocs,
4698 bfd_elf64_swap_symbol_out,
4699 bfd_elf64_slurp_reloc_table,
4700 bfd_elf64_slurp_symbol_table,
4701 bfd_elf64_swap_dyn_in,
4702 bfd_elf64_swap_dyn_out,
4709 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4710 #define TARGET_LITTLE_NAME "elf64-alpha"
4711 #define ELF_ARCH bfd_arch_alpha
4712 #define ELF_MACHINE_CODE EM_ALPHA
4713 #define ELF_MAXPAGESIZE 0x10000
4715 #define bfd_elf64_bfd_link_hash_table_create \
4716 elf64_alpha_bfd_link_hash_table_create
4718 #define bfd_elf64_bfd_reloc_type_lookup \
4719 elf64_alpha_bfd_reloc_type_lookup
4720 #define elf_info_to_howto \
4721 elf64_alpha_info_to_howto
4723 #define bfd_elf64_mkobject \
4724 elf64_alpha_mkobject
4725 #define elf_backend_object_p \
4726 elf64_alpha_object_p
4728 #define elf_backend_section_from_shdr \
4729 elf64_alpha_section_from_shdr
4730 #define elf_backend_fake_sections \
4731 elf64_alpha_fake_sections
4733 #define bfd_elf64_bfd_is_local_label_name \
4734 elf64_alpha_is_local_label_name
4735 #define bfd_elf64_find_nearest_line \
4736 elf64_alpha_find_nearest_line
4737 #define bfd_elf64_bfd_relax_section \
4738 elf64_alpha_relax_section
4740 #define elf_backend_add_symbol_hook \
4741 elf64_alpha_add_symbol_hook
4742 #define elf_backend_check_relocs \
4743 elf64_alpha_check_relocs
4744 #define elf_backend_create_dynamic_sections \
4745 elf64_alpha_create_dynamic_sections
4746 #define elf_backend_adjust_dynamic_symbol \
4747 elf64_alpha_adjust_dynamic_symbol
4748 #define elf_backend_always_size_sections \
4749 elf64_alpha_always_size_sections
4750 #define elf_backend_size_dynamic_sections \
4751 elf64_alpha_size_dynamic_sections
4752 #define elf_backend_relocate_section \
4753 elf64_alpha_relocate_section
4754 #define elf_backend_finish_dynamic_symbol \
4755 elf64_alpha_finish_dynamic_symbol
4756 #define elf_backend_finish_dynamic_sections \
4757 elf64_alpha_finish_dynamic_sections
4758 #define bfd_elf64_bfd_final_link \
4759 elf64_alpha_final_link
4761 #define elf_backend_ecoff_debug_swap \
4762 &elf64_alpha_ecoff_debug_swap
4764 #define elf_backend_size_info \
4767 /* A few constants that determine how the .plt section is set up. */
4768 #define elf_backend_want_got_plt 0
4769 #define elf_backend_plt_readonly 0
4770 #define elf_backend_want_plt_sym 1
4771 #define elf_backend_got_header_size 0
4772 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4774 #include "elf64-target.h"