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 boolean elf64_alpha_mkobject PARAMS ((bfd *));
50 static struct bfd_hash_entry * elf64_alpha_link_hash_newfunc
51 PARAMS((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
52 static struct bfd_link_hash_table * elf64_alpha_bfd_link_hash_table_create
55 static bfd_reloc_status_type elf64_alpha_reloc_nil
56 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
57 static bfd_reloc_status_type elf64_alpha_reloc_bad
58 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
59 static bfd_reloc_status_type elf64_alpha_do_reloc_gpdisp
60 PARAMS((bfd *, bfd_vma, bfd_byte *, bfd_byte *));
61 static bfd_reloc_status_type elf64_alpha_reloc_gpdisp
62 PARAMS((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
64 static reloc_howto_type * elf64_alpha_bfd_reloc_type_lookup
65 PARAMS((bfd *, bfd_reloc_code_real_type));
66 static void elf64_alpha_info_to_howto
67 PARAMS((bfd *, arelent *, Elf64_Internal_Rela *));
69 static boolean elf64_alpha_object_p
71 static boolean elf64_alpha_section_from_shdr
72 PARAMS((bfd *, Elf64_Internal_Shdr *, char *));
73 static boolean elf64_alpha_fake_sections
74 PARAMS((bfd *, Elf64_Internal_Shdr *, asection *));
75 static boolean elf64_alpha_create_got_section
76 PARAMS((bfd *, struct bfd_link_info *));
77 static boolean elf64_alpha_create_dynamic_sections
78 PARAMS((bfd *, struct bfd_link_info *));
80 static boolean elf64_alpha_read_ecoff_info
81 PARAMS((bfd *, asection *, struct ecoff_debug_info *));
82 static boolean elf64_alpha_is_local_label_name
83 PARAMS((bfd *, const char *));
84 static boolean elf64_alpha_find_nearest_line
85 PARAMS((bfd *, asection *, asymbol **, bfd_vma, const char **,
86 const char **, unsigned int *));
88 #if defined(__STDC__) || defined(ALMOST_STDC)
89 struct alpha_elf_link_hash_entry;
92 static boolean elf64_alpha_output_extsym
93 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
95 static boolean elf64_alpha_can_merge_gots
96 PARAMS((bfd *, bfd *));
97 static void elf64_alpha_merge_gots
98 PARAMS((bfd *, bfd *));
99 static boolean elf64_alpha_calc_got_offsets_for_symbol
100 PARAMS ((struct alpha_elf_link_hash_entry *, PTR));
101 static void elf64_alpha_calc_got_offsets PARAMS ((struct bfd_link_info *));
102 static boolean elf64_alpha_size_got_sections
103 PARAMS ((bfd *, struct bfd_link_info *));
104 static boolean elf64_alpha_always_size_sections
105 PARAMS ((bfd *, struct bfd_link_info *));
106 static boolean elf64_alpha_calc_dynrel_sizes
107 PARAMS ((struct alpha_elf_link_hash_entry *, struct bfd_link_info *));
108 static boolean elf64_alpha_add_symbol_hook
109 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
110 const char **, flagword *, asection **, bfd_vma *));
111 static boolean elf64_alpha_check_relocs
112 PARAMS((bfd *, struct bfd_link_info *, asection *sec,
113 const Elf_Internal_Rela *));
114 static boolean elf64_alpha_adjust_dynamic_symbol
115 PARAMS((struct bfd_link_info *, struct elf_link_hash_entry *));
116 static boolean elf64_alpha_size_dynamic_sections
117 PARAMS((bfd *, struct bfd_link_info *));
118 static boolean elf64_alpha_relocate_section
119 PARAMS((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
120 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
121 static boolean elf64_alpha_finish_dynamic_symbol
122 PARAMS((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
123 Elf_Internal_Sym *));
124 static boolean elf64_alpha_finish_dynamic_sections
125 PARAMS((bfd *, struct bfd_link_info *));
126 static boolean elf64_alpha_final_link
127 PARAMS((bfd *, struct bfd_link_info *));
128 static boolean elf64_alpha_merge_ind_symbols
129 PARAMS((struct alpha_elf_link_hash_entry *, PTR));
130 static Elf_Internal_Rela * elf64_alpha_find_reloc_at_ofs
131 PARAMS ((Elf_Internal_Rela *, Elf_Internal_Rela *, bfd_vma, int));
134 struct alpha_elf_link_hash_entry
136 struct elf_link_hash_entry root;
138 /* External symbol information. */
141 /* Cumulative flags for all the .got entries. */
144 /* Contexts (LITUSE) in which a literal was referenced. */
145 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
146 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
147 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
148 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
150 /* Used to implement multiple .got subsections. */
151 struct alpha_elf_got_entry
153 struct alpha_elf_got_entry *next;
155 /* which .got subsection? */
158 /* the addend in effect for this entry. */
161 /* the .got offset for this entry. */
166 /* An additional flag. */
167 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
172 /* used to count non-got, non-plt relocations for delayed sizing
173 of relocation sections. */
174 struct alpha_elf_reloc_entry
176 struct alpha_elf_reloc_entry *next;
178 /* which .reloc section? */
181 /* what kind of relocation? */
184 /* how many did we find? */
189 /* Alpha ELF linker hash table. */
191 struct alpha_elf_link_hash_table
193 struct elf_link_hash_table root;
195 /* The head of a list of .got subsections linked through
196 alpha_elf_tdata(abfd)->got_link_next. */
200 /* Look up an entry in a Alpha ELF linker hash table. */
202 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
203 ((struct alpha_elf_link_hash_entry *) \
204 elf_link_hash_lookup (&(table)->root, (string), (create), \
207 /* Traverse a Alpha ELF linker hash table. */
209 #define alpha_elf_link_hash_traverse(table, func, info) \
210 (elf_link_hash_traverse \
212 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
215 /* Get the Alpha ELF linker hash table from a link_info structure. */
217 #define alpha_elf_hash_table(p) \
218 ((struct alpha_elf_link_hash_table *) ((p)->hash))
220 /* Get the object's symbols as our own entry type. */
222 #define alpha_elf_sym_hashes(abfd) \
223 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
225 /* Should we do dynamic things to this symbol? */
227 #define alpha_elf_dynamic_symbol_p(h, info) \
228 ((((info)->shared && !(info)->symbolic) \
229 || (((h)->elf_link_hash_flags \
230 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)) \
231 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)) \
232 || (h)->root.type == bfd_link_hash_undefweak \
233 || (h)->root.type == bfd_link_hash_defweak) \
234 && (h)->dynindx != -1)
236 /* Create an entry in a Alpha ELF linker hash table. */
238 static struct bfd_hash_entry *
239 elf64_alpha_link_hash_newfunc (entry, table, string)
240 struct bfd_hash_entry *entry;
241 struct bfd_hash_table *table;
244 struct alpha_elf_link_hash_entry *ret =
245 (struct alpha_elf_link_hash_entry *) entry;
247 /* Allocate the structure if it has not already been allocated by a
249 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
250 ret = ((struct alpha_elf_link_hash_entry *)
251 bfd_hash_allocate (table,
252 sizeof (struct alpha_elf_link_hash_entry)));
253 if (ret == (struct alpha_elf_link_hash_entry *) NULL)
254 return (struct bfd_hash_entry *) ret;
256 /* Call the allocation method of the superclass. */
257 ret = ((struct alpha_elf_link_hash_entry *)
258 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
260 if (ret != (struct alpha_elf_link_hash_entry *) NULL)
262 /* Set local fields. */
263 memset (&ret->esym, 0, sizeof (EXTR));
264 /* We use -2 as a marker to indicate that the information has
265 not been set. -1 means there is no associated ifd. */
268 ret->got_entries = NULL;
269 ret->reloc_entries = NULL;
272 return (struct bfd_hash_entry *) ret;
275 /* Create a Alpha ELF linker hash table. */
277 static struct bfd_link_hash_table *
278 elf64_alpha_bfd_link_hash_table_create (abfd)
281 struct alpha_elf_link_hash_table *ret;
283 ret = ((struct alpha_elf_link_hash_table *)
284 bfd_zalloc (abfd, sizeof (struct alpha_elf_link_hash_table)));
285 if (ret == (struct alpha_elf_link_hash_table *) NULL)
288 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
289 elf64_alpha_link_hash_newfunc))
291 bfd_release (abfd, ret);
295 return &ret->root.root;
298 /* We have some private fields hanging off of the elf_tdata structure. */
300 struct alpha_elf_obj_tdata
302 struct elf_obj_tdata root;
304 /* For every input file, these are the got entries for that object's
306 struct alpha_elf_got_entry ** local_got_entries;
308 /* For every input file, this is the object that owns the got that
309 this input file uses. */
312 /* For every got, this is a linked list through the objects using this got */
313 bfd *in_got_link_next;
315 /* For every got, this is a link to the next got subsegment. */
318 /* For every got, this is the section. */
321 /* For every got, this is it's total number of *entries*. */
322 int total_got_entries;
324 /* For every got, this is the sum of the number of *entries* required
325 to hold all of the member object's local got. */
326 int n_local_got_entries;
329 #define alpha_elf_tdata(abfd) \
330 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
333 elf64_alpha_mkobject (abfd)
336 abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
337 if (abfd->tdata.any == NULL)
343 elf64_alpha_object_p (abfd)
346 /* Allocate our special target data. */
347 struct alpha_elf_obj_tdata *new_tdata;
348 new_tdata = bfd_zalloc (abfd, sizeof (struct alpha_elf_obj_tdata));
349 if (new_tdata == NULL)
351 new_tdata->root = *abfd->tdata.elf_obj_data;
352 abfd->tdata.any = new_tdata;
354 /* Set the right machine number for an Alpha ELF file. */
355 return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
358 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
359 from smaller values. Start with zero, widen, *then* decrement. */
360 #define MINUS_ONE (((bfd_vma)0) - 1)
362 static reloc_howto_type elf64_alpha_howto_table[] =
364 HOWTO (R_ALPHA_NONE, /* type */
366 0, /* size (0 = byte, 1 = short, 2 = long) */
368 true, /* pc_relative */
370 complain_overflow_dont, /* complain_on_overflow */
371 elf64_alpha_reloc_nil, /* special_function */
373 false, /* partial_inplace */
376 true), /* pcrel_offset */
378 /* A 32 bit reference to a symbol. */
379 HOWTO (R_ALPHA_REFLONG, /* type */
381 2, /* size (0 = byte, 1 = short, 2 = long) */
383 false, /* pc_relative */
385 complain_overflow_bitfield, /* complain_on_overflow */
386 0, /* special_function */
387 "REFLONG", /* name */
388 false, /* partial_inplace */
389 0xffffffff, /* src_mask */
390 0xffffffff, /* dst_mask */
391 false), /* pcrel_offset */
393 /* A 64 bit reference to a symbol. */
394 HOWTO (R_ALPHA_REFQUAD, /* type */
396 4, /* size (0 = byte, 1 = short, 2 = long) */
398 false, /* pc_relative */
400 complain_overflow_bitfield, /* complain_on_overflow */
401 0, /* special_function */
402 "REFQUAD", /* name */
403 false, /* partial_inplace */
404 MINUS_ONE, /* src_mask */
405 MINUS_ONE, /* dst_mask */
406 false), /* pcrel_offset */
408 /* A 32 bit GP relative offset. This is just like REFLONG except
409 that when the value is used the value of the gp register will be
411 HOWTO (R_ALPHA_GPREL32, /* type */
413 2, /* size (0 = byte, 1 = short, 2 = long) */
415 false, /* pc_relative */
417 complain_overflow_bitfield, /* complain_on_overflow */
418 0, /* special_function */
419 "GPREL32", /* name */
420 false, /* partial_inplace */
421 0xffffffff, /* src_mask */
422 0xffffffff, /* dst_mask */
423 false), /* pcrel_offset */
425 /* Used for an instruction that refers to memory off the GP register. */
426 HOWTO (R_ALPHA_LITERAL, /* type */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
430 false, /* pc_relative */
432 complain_overflow_signed, /* complain_on_overflow */
433 0, /* special_function */
434 "ELF_LITERAL", /* name */
435 false, /* partial_inplace */
436 0xffff, /* src_mask */
437 0xffff, /* dst_mask */
438 false), /* pcrel_offset */
440 /* This reloc only appears immediately following an ELF_LITERAL reloc.
441 It identifies a use of the literal. The symbol index is special:
442 1 means the literal address is in the base register of a memory
443 format instruction; 2 means the literal address is in the byte
444 offset register of a byte-manipulation instruction; 3 means the
445 literal address is in the target register of a jsr instruction.
446 This does not actually do any relocation. */
447 HOWTO (R_ALPHA_LITUSE, /* type */
449 2, /* size (0 = byte, 1 = short, 2 = long) */
451 false, /* pc_relative */
453 complain_overflow_dont, /* complain_on_overflow */
454 elf64_alpha_reloc_nil, /* special_function */
456 false, /* partial_inplace */
459 false), /* pcrel_offset */
461 /* Load the gp register. This is always used for a ldah instruction
462 which loads the upper 16 bits of the gp register. The symbol
463 index of the GPDISP instruction is an offset in bytes to the lda
464 instruction that loads the lower 16 bits. The value to use for
465 the relocation is the difference between the GP value and the
466 current location; the load will always be done against a register
467 holding the current address.
469 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
470 any offset is present in the instructions, it is an offset from
471 the register to the ldah instruction. This lets us avoid any
472 stupid hackery like inventing a gp value to do partial relocation
473 against. Also unlike ECOFF, we do the whole relocation off of
474 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
475 space consuming bit, that, since all the information was present
476 in the GPDISP_HI16 reloc. */
477 HOWTO (R_ALPHA_GPDISP, /* type */
479 2, /* size (0 = byte, 1 = short, 2 = long) */
481 false, /* pc_relative */
483 complain_overflow_dont, /* complain_on_overflow */
484 elf64_alpha_reloc_gpdisp, /* special_function */
486 false, /* partial_inplace */
487 0xffff, /* src_mask */
488 0xffff, /* dst_mask */
489 true), /* pcrel_offset */
491 /* A 21 bit branch. */
492 HOWTO (R_ALPHA_BRADDR, /* type */
494 2, /* size (0 = byte, 1 = short, 2 = long) */
496 true, /* pc_relative */
498 complain_overflow_signed, /* complain_on_overflow */
499 0, /* special_function */
501 false, /* partial_inplace */
502 0x1fffff, /* src_mask */
503 0x1fffff, /* dst_mask */
504 true), /* pcrel_offset */
506 /* A hint for a jump to a register. */
507 HOWTO (R_ALPHA_HINT, /* type */
509 2, /* size (0 = byte, 1 = short, 2 = long) */
511 true, /* pc_relative */
513 complain_overflow_dont, /* complain_on_overflow */
514 0, /* special_function */
516 false, /* partial_inplace */
517 0x3fff, /* src_mask */
518 0x3fff, /* dst_mask */
519 true), /* pcrel_offset */
521 /* 16 bit PC relative offset. */
522 HOWTO (R_ALPHA_SREL16, /* type */
524 1, /* size (0 = byte, 1 = short, 2 = long) */
526 true, /* pc_relative */
528 complain_overflow_signed, /* complain_on_overflow */
529 0, /* special_function */
531 false, /* partial_inplace */
532 0xffff, /* src_mask */
533 0xffff, /* dst_mask */
534 false), /* pcrel_offset */
536 /* 32 bit PC relative offset. */
537 HOWTO (R_ALPHA_SREL32, /* type */
539 2, /* size (0 = byte, 1 = short, 2 = long) */
541 true, /* pc_relative */
543 complain_overflow_signed, /* complain_on_overflow */
544 0, /* special_function */
546 false, /* partial_inplace */
547 0xffffffff, /* src_mask */
548 0xffffffff, /* dst_mask */
549 false), /* pcrel_offset */
551 /* A 64 bit PC relative offset. */
552 HOWTO (R_ALPHA_SREL64, /* type */
554 4, /* size (0 = byte, 1 = short, 2 = long) */
556 true, /* pc_relative */
558 complain_overflow_signed, /* complain_on_overflow */
559 0, /* special_function */
561 false, /* partial_inplace */
562 MINUS_ONE, /* src_mask */
563 MINUS_ONE, /* dst_mask */
564 false), /* pcrel_offset */
566 /* Push a value on the reloc evaluation stack. */
567 /* Not implemented -- it's dumb. */
568 HOWTO (R_ALPHA_OP_PUSH, /* type */
570 0, /* size (0 = byte, 1 = short, 2 = long) */
572 false, /* pc_relative */
574 complain_overflow_dont, /* complain_on_overflow */
575 elf64_alpha_reloc_bad, /* special_function */
576 "OP_PUSH", /* name */
577 false, /* partial_inplace */
580 false), /* pcrel_offset */
582 /* Store the value from the stack at the given address. Store it in
583 a bitfield of size r_size starting at bit position r_offset. */
584 /* Not implemented -- it's dumb. */
585 HOWTO (R_ALPHA_OP_STORE, /* type */
587 4, /* size (0 = byte, 1 = short, 2 = long) */
589 false, /* pc_relative */
591 complain_overflow_dont, /* complain_on_overflow */
592 elf64_alpha_reloc_bad, /* special_function */
593 "OP_STORE", /* name */
594 false, /* partial_inplace */
596 MINUS_ONE, /* dst_mask */
597 false), /* pcrel_offset */
599 /* Subtract the reloc address from the value on the top of the
601 /* Not implemented -- it's dumb. */
602 HOWTO (R_ALPHA_OP_PSUB, /* type */
604 0, /* size (0 = byte, 1 = short, 2 = long) */
606 false, /* pc_relative */
608 complain_overflow_dont, /* complain_on_overflow */
609 elf64_alpha_reloc_bad, /* special_function */
610 "OP_PSUB", /* name */
611 false, /* partial_inplace */
614 false), /* pcrel_offset */
616 /* Shift the value on the top of the relocation stack right by the
618 /* Not implemented -- it's dumb. */
619 HOWTO (R_ALPHA_OP_PRSHIFT, /* type */
621 0, /* size (0 = byte, 1 = short, 2 = long) */
623 false, /* pc_relative */
625 complain_overflow_dont, /* complain_on_overflow */
626 elf64_alpha_reloc_bad, /* special_function */
627 "OP_PRSHIFT", /* name */
628 false, /* partial_inplace */
631 false), /* pcrel_offset */
633 /* Change the value of GP used by +r_addend until the next GPVALUE or the
634 end of the input bfd. */
635 /* Not implemented -- it's dumb. */
636 HOWTO (R_ALPHA_GPVALUE,
638 0, /* size (0 = byte, 1 = short, 2 = long) */
640 false, /* pc_relative */
642 complain_overflow_dont, /* complain_on_overflow */
643 elf64_alpha_reloc_bad, /* special_function */
644 "GPVALUE", /* name */
645 false, /* partial_inplace */
648 false), /* pcrel_offset */
650 /* The high 16 bits of the displacement from GP to the target. */
651 HOWTO (R_ALPHA_GPRELHIGH,
653 2, /* size (0 = byte, 1 = short, 2 = long) */
655 false, /* pc_relative */
657 complain_overflow_signed, /* complain_on_overflow */
658 elf64_alpha_reloc_bad, /* special_function */
659 "GPRELHIGH", /* name */
660 false, /* partial_inplace */
661 0xffff, /* src_mask */
662 0xffff, /* dst_mask */
663 false), /* pcrel_offset */
665 /* The low 16 bits of the displacement from GP to the target. */
666 HOWTO (R_ALPHA_GPRELLOW,
668 2, /* size (0 = byte, 1 = short, 2 = long) */
670 false, /* pc_relative */
672 complain_overflow_dont, /* complain_on_overflow */
673 elf64_alpha_reloc_bad, /* special_function */
674 "GPRELLOW", /* name */
675 false, /* partial_inplace */
676 0xffff, /* src_mask */
677 0xffff, /* dst_mask */
678 false), /* pcrel_offset */
680 /* A 16-bit displacement from the GP to the target. */
681 /* XXX: Not implemented. */
682 HOWTO (R_ALPHA_IMMED_GP_16,
684 2, /* size (0 = byte, 1 = short, 2 = long) */
686 false, /* pc_relative */
688 complain_overflow_signed, /* complain_on_overflow */
689 0, /* special_function */
690 "IMMED_GP_16", /* name */
691 false, /* partial_inplace */
692 0xffff, /* src_mask */
693 0xffff, /* dst_mask */
694 false), /* pcrel_offset */
696 /* The high bits of a 32-bit displacement from the GP to the target; the
697 low bits are supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
698 /* XXX: Not implemented. */
699 HOWTO (R_ALPHA_IMMED_GP_HI32,
701 0, /* size (0 = byte, 1 = short, 2 = long) */
703 false, /* pc_relative */
705 complain_overflow_dont, /* complain_on_overflow */
706 elf64_alpha_reloc_bad, /* special_function */
707 "IMMED_GP_HI32", /* name */
708 false, /* partial_inplace */
711 false), /* pcrel_offset */
713 /* The high bits of a 32-bit displacement to the starting address of the
714 current section (the relocation target is ignored); the low bits are
715 supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
716 /* XXX: Not implemented. */
717 HOWTO (R_ALPHA_IMMED_SCN_HI32,
719 0, /* size (0 = byte, 1 = short, 2 = long) */
721 false, /* pc_relative */
723 complain_overflow_dont, /* complain_on_overflow */
724 elf64_alpha_reloc_bad, /* special_function */
725 "IMMED_SCN_HI32", /* name */
726 false, /* partial_inplace */
729 false), /* pcrel_offset */
731 /* The high bits of a 32-bit displacement from the previous br, bsr, jsr
732 or jmp insn (as tagged by a BRADDR or HINT reloc) to the target; the
733 low bits are supplied by subsequent R_ALPHA_IMMED_LO32 relocs. */
734 /* XXX: Not implemented. */
735 HOWTO (R_ALPHA_IMMED_BR_HI32,
737 0, /* size (0 = byte, 1 = short, 2 = long) */
739 false, /* pc_relative */
741 complain_overflow_dont, /* complain_on_overflow */
742 elf64_alpha_reloc_bad, /* special_function */
743 "IMMED_BR_HI32", /* name */
744 false, /* partial_inplace */
747 false), /* pcrel_offset */
749 /* The low 16 bits of a displacement calculated in a previous HI32 reloc. */
750 /* XXX: Not implemented. */
751 HOWTO (R_ALPHA_IMMED_LO32,
753 0, /* size (0 = byte, 1 = short, 2 = long) */
755 false, /* pc_relative */
757 complain_overflow_dont, /* complain_on_overflow */
758 elf64_alpha_reloc_bad, /* special_function */
759 "IMMED_LO32", /* name */
760 false, /* partial_inplace */
763 false), /* pcrel_offset */
765 /* Misc ELF relocations. */
767 /* A dynamic relocation to copy the target into our .dynbss section. */
768 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
769 is present because every other ELF has one, but should not be used
770 because .dynbss is an ugly thing. */
777 complain_overflow_dont,
778 bfd_elf_generic_reloc,
785 /* A dynamic relocation for a .got entry. */
786 HOWTO (R_ALPHA_GLOB_DAT,
792 complain_overflow_dont,
793 bfd_elf_generic_reloc,
800 /* A dynamic relocation for a .plt entry. */
801 HOWTO (R_ALPHA_JMP_SLOT,
807 complain_overflow_dont,
808 bfd_elf_generic_reloc,
815 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
816 HOWTO (R_ALPHA_RELATIVE,
822 complain_overflow_dont,
823 bfd_elf_generic_reloc,
831 /* A relocation function which doesn't do anything. */
833 static bfd_reloc_status_type
834 elf64_alpha_reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
841 char **error_message;
844 reloc->address += sec->output_offset;
848 /* A relocation function used for an unsupported reloc. */
850 static bfd_reloc_status_type
851 elf64_alpha_reloc_bad (abfd, reloc, sym, data, sec, output_bfd, error_message)
858 char **error_message;
861 reloc->address += sec->output_offset;
862 return bfd_reloc_notsupported;
865 /* Do the work of the GPDISP relocation. */
867 static bfd_reloc_status_type
868 elf64_alpha_do_reloc_gpdisp (abfd, gpdisp, p_ldah, p_lda)
874 bfd_reloc_status_type ret = bfd_reloc_ok;
876 unsigned long i_ldah, i_lda;
878 i_ldah = bfd_get_32 (abfd, p_ldah);
879 i_lda = bfd_get_32 (abfd, p_lda);
881 /* Complain if the instructions are not correct. */
882 if (((i_ldah >> 26) & 0x3f) != 0x09
883 || ((i_lda >> 26) & 0x3f) != 0x08)
884 ret = bfd_reloc_dangerous;
886 /* Extract the user-supplied offset, mirroring the sign extensions
887 that the instructions perform. */
888 addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
889 addend = (addend ^ 0x80008000) - 0x80008000;
893 if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
894 || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
895 ret = bfd_reloc_overflow;
897 /* compensate for the sign extension again. */
898 i_ldah = ((i_ldah & 0xffff0000)
899 | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
900 i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
902 bfd_put_32 (abfd, i_ldah, p_ldah);
903 bfd_put_32 (abfd, i_lda, p_lda);
908 /* The special function for the GPDISP reloc. */
910 static bfd_reloc_status_type
911 elf64_alpha_reloc_gpdisp (abfd, reloc_entry, sym, data, input_section,
914 arelent *reloc_entry;
917 asection *input_section;
921 bfd_reloc_status_type ret;
922 bfd_vma gp, relocation;
923 bfd_byte *p_ldah, *p_lda;
925 /* Don't do anything if we're not doing a final link. */
928 reloc_entry->address += input_section->output_offset;
932 if (reloc_entry->address > input_section->_cooked_size ||
933 reloc_entry->address + reloc_entry->addend > input_section->_cooked_size)
934 return bfd_reloc_outofrange;
936 /* The gp used in the portion of the output object to which this
937 input object belongs is cached on the input bfd. */
938 gp = _bfd_get_gp_value (abfd);
940 relocation = (input_section->output_section->vma
941 + input_section->output_offset
942 + reloc_entry->address);
944 p_ldah = (bfd_byte *) data + reloc_entry->address;
945 p_lda = p_ldah + reloc_entry->addend;
947 ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
949 /* Complain if the instructions are not correct. */
950 if (ret == bfd_reloc_dangerous)
951 *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
956 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
960 bfd_reloc_code_real_type bfd_reloc_val;
964 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
966 {BFD_RELOC_NONE, R_ALPHA_NONE},
967 {BFD_RELOC_32, R_ALPHA_REFLONG},
968 {BFD_RELOC_64, R_ALPHA_REFQUAD},
969 {BFD_RELOC_CTOR, R_ALPHA_REFQUAD},
970 {BFD_RELOC_GPREL32, R_ALPHA_GPREL32},
971 {BFD_RELOC_ALPHA_ELF_LITERAL, R_ALPHA_LITERAL},
972 {BFD_RELOC_ALPHA_LITUSE, R_ALPHA_LITUSE},
973 {BFD_RELOC_ALPHA_GPDISP, R_ALPHA_GPDISP},
974 {BFD_RELOC_23_PCREL_S2, R_ALPHA_BRADDR},
975 {BFD_RELOC_ALPHA_HINT, R_ALPHA_HINT},
976 {BFD_RELOC_16_PCREL, R_ALPHA_SREL16},
977 {BFD_RELOC_32_PCREL, R_ALPHA_SREL32},
978 {BFD_RELOC_64_PCREL, R_ALPHA_SREL64},
980 /* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process
981 the explicit !<reloc>!sequence relocations, and are mapped into the normal
982 relocations at the end of processing. */
983 {BFD_RELOC_ALPHA_USER_LITERAL, R_ALPHA_LITERAL},
984 {BFD_RELOC_ALPHA_USER_LITUSE_BASE, R_ALPHA_LITUSE},
985 {BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF, R_ALPHA_LITUSE},
986 {BFD_RELOC_ALPHA_USER_LITUSE_JSR, R_ALPHA_LITUSE},
987 {BFD_RELOC_ALPHA_USER_GPDISP, R_ALPHA_GPDISP},
988 {BFD_RELOC_ALPHA_USER_GPRELHIGH, R_ALPHA_GPRELHIGH},
989 {BFD_RELOC_ALPHA_USER_GPRELLOW, R_ALPHA_GPRELLOW},
992 /* Given a BFD reloc type, return a HOWTO structure. */
994 static reloc_howto_type *
995 elf64_alpha_bfd_reloc_type_lookup (abfd, code)
997 bfd_reloc_code_real_type code;
999 const struct elf_reloc_map *i, *e;
1000 i = e = elf64_alpha_reloc_map;
1001 e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1004 if (i->bfd_reloc_val == code)
1005 return &elf64_alpha_howto_table[i->elf_reloc_val];
1010 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1013 elf64_alpha_info_to_howto (abfd, cache_ptr, dst)
1016 Elf64_Internal_Rela *dst;
1020 r_type = ELF64_R_TYPE(dst->r_info);
1021 BFD_ASSERT (r_type < (unsigned int) R_ALPHA_max);
1022 cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1025 /* These functions do relaxation for Alpha ELF.
1027 Currently I'm only handling what I can do with existing compiler
1028 and assembler support, which means no instructions are removed,
1029 though some may be nopped. At this time GCC does not emit enough
1030 information to do all of the relaxing that is possible. It will
1031 take some not small amount of work for that to happen.
1033 There are a couple of interesting papers that I once read on this
1034 subject, that I cannot find references to at the moment, that
1035 related to Alpha in particular. They are by David Wall, then of
1039 #define OP_LDAH 0x09
1040 #define INSN_JSR 0x68004000
1041 #define INSN_JSR_MASK 0xfc00c000
1045 #define INSN_UNOP 0x2fe00000
1047 struct alpha_relax_info
1052 Elf_Internal_Rela *relocs, *relend;
1053 struct bfd_link_info *link_info;
1054 boolean changed_contents;
1055 boolean changed_relocs;
1059 struct alpha_elf_link_hash_entry *h;
1060 struct alpha_elf_got_entry *gotent;
1061 unsigned char other;
1064 static Elf_Internal_Rela * elf64_alpha_relax_with_lituse
1065 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1066 Elf_Internal_Rela *irel, Elf_Internal_Rela *irelend));
1068 static boolean elf64_alpha_relax_without_lituse
1069 PARAMS((struct alpha_relax_info *info, bfd_vma symval,
1070 Elf_Internal_Rela *irel));
1072 static bfd_vma elf64_alpha_relax_opt_call
1073 PARAMS((struct alpha_relax_info *info, bfd_vma symval));
1075 static boolean elf64_alpha_relax_section
1076 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
1079 static Elf_Internal_Rela *
1080 elf64_alpha_find_reloc_at_ofs (rel, relend, offset, type)
1081 Elf_Internal_Rela *rel, *relend;
1085 while (rel < relend)
1087 if (rel->r_offset == offset && ELF64_R_TYPE (rel->r_info) == type)
1094 static Elf_Internal_Rela *
1095 elf64_alpha_relax_with_lituse (info, symval, irel, irelend)
1096 struct alpha_relax_info *info;
1098 Elf_Internal_Rela *irel, *irelend;
1100 Elf_Internal_Rela *urel;
1101 int flags, count, i;
1102 bfd_signed_vma disp;
1105 boolean lit_reused = false;
1106 boolean all_optimized = true;
1107 unsigned int lit_insn;
1109 lit_insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1110 if (lit_insn >> 26 != OP_LDQ)
1112 ((*_bfd_error_handler)
1113 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1114 bfd_get_filename (info->abfd), info->sec->name,
1115 (unsigned long)irel->r_offset));
1119 /* Summarize how this particular LITERAL is used. */
1120 for (urel = irel+1, flags = count = 0; urel < irelend; ++urel, ++count)
1122 if (ELF64_R_TYPE (urel->r_info) != R_ALPHA_LITUSE)
1124 if (urel->r_addend >= 0 && urel->r_addend <= 3)
1125 flags |= 1 << urel->r_addend;
1128 /* A little preparation for the loop... */
1129 disp = symval - info->gp;
1131 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1135 bfd_signed_vma xdisp;
1137 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1139 switch (urel->r_addend)
1141 default: /* 0 = ADDRESS FORMAT */
1142 /* This type is really just a placeholder to note that all
1143 uses cannot be optimized, but to still allow some. */
1144 all_optimized = false;
1147 case 1: /* MEM FORMAT */
1148 /* We can always optimize 16-bit displacements. */
1150 /* Extract the displacement from the instruction, sign-extending
1151 it if necessary, then test whether it is within 16 or 32 bits
1152 displacement from GP. */
1153 insn_disp = insn & 0x0000ffff;
1154 if (insn_disp & 0x00008000)
1155 insn_disp |= 0xffff0000; /* Negative: sign-extend. */
1157 xdisp = disp + insn_disp;
1158 fits16 = (xdisp >= - (bfd_signed_vma) 0x00008000 && xdisp < 0x00008000);
1159 fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000 && xdisp < 0x7fff8000);
1163 /* Take the op code and dest from this insn, take the base
1164 register from the literal insn. Leave the offset alone. */
1165 insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
1166 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1168 urel->r_addend = irel->r_addend;
1169 info->changed_relocs = true;
1171 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1172 info->changed_contents = true;
1175 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1176 else if (fits32 && !(flags & ~6))
1178 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1180 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1182 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1183 bfd_put_32 (info->abfd, lit_insn,
1184 info->contents + irel->r_offset);
1186 info->changed_contents = true;
1188 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1190 urel->r_addend = irel->r_addend;
1191 info->changed_relocs = true;
1194 all_optimized = false;
1197 case 2: /* BYTE OFFSET FORMAT */
1198 /* We can always optimize byte instructions. */
1200 /* FIXME: sanity check the insn for byte op. Check that the
1201 literal dest reg is indeed Rb in the byte insn. */
1203 insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
1205 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1207 info->changed_relocs = true;
1209 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1210 info->changed_contents = true;
1213 case 3: /* CALL FORMAT */
1215 /* If not zero, place to jump without needing pv. */
1216 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1217 bfd_vma org = (info->sec->output_section->vma
1218 + info->sec->output_offset
1219 + urel->r_offset + 4);
1220 bfd_signed_vma odisp;
1222 odisp = (optdest ? optdest : symval) - org;
1223 if (odisp >= -0x400000 && odisp < 0x400000)
1225 Elf_Internal_Rela *xrel;
1227 /* Preserve branch prediction call stack when possible. */
1228 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1229 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1231 insn = (OP_BR << 26) | (insn & 0x03e00000);
1233 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1235 urel->r_addend = irel->r_addend;
1238 urel->r_addend += optdest - symval;
1240 all_optimized = false;
1242 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1244 /* Kill any HINT reloc that might exist for this insn. */
1245 xrel = (elf64_alpha_find_reloc_at_ofs
1246 (info->relocs, info->relend, urel->r_offset,
1249 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1251 info->changed_contents = true;
1252 info->changed_relocs = true;
1255 all_optimized = false;
1257 /* ??? If target gp == current gp we can eliminate the gp reload.
1258 This does depend on every place a gp could be reloaded will
1259 be, which currently happens for all code produced by gcc, but
1260 not necessarily by hand-coded assembly, or if sibling calls
1263 Perhaps conditionalize this on a flag being set in the target
1264 object file's header, and have gcc set it? */
1270 /* If all cases were optimized, we can reduce the use count on this
1271 got entry by one, possibly eliminating it. */
1274 info->gotent->use_count -= 1;
1275 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1277 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1279 /* If the literal instruction is no longer needed (it may have been
1280 reused. We can eliminate it.
1281 ??? For now, I don't want to deal with compacting the section,
1282 so just nop it out. */
1285 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1286 info->changed_relocs = true;
1288 bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
1289 info->changed_contents = true;
1293 return irel + count;
1297 elf64_alpha_relax_opt_call (info, symval)
1298 struct alpha_relax_info *info;
1301 /* If the function has the same gp, and we can identify that the
1302 function does not use its function pointer, we can eliminate the
1305 /* If the symbol is marked NOPV, we are being told the function never
1306 needs its procedure value. */
1307 if (info->other == STO_ALPHA_NOPV)
1310 /* If the symbol is marked STD_GP, we are being told the function does
1311 a normal ldgp in the first two words. */
1312 else if (info->other == STO_ALPHA_STD_GPLOAD)
1315 /* Otherwise, we may be able to identify a GP load in the first two
1316 words, which we can then skip. */
1319 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1322 /* Load the relocations from the section that the target symbol is in. */
1323 if (info->sec == info->tsec)
1325 tsec_relocs = info->relocs;
1326 tsec_relend = info->relend;
1331 tsec_relocs = (_bfd_elf64_link_read_relocs
1332 (info->abfd, info->tsec, (PTR) NULL,
1333 (Elf_Internal_Rela *) NULL,
1334 info->link_info->keep_memory));
1335 if (tsec_relocs == NULL)
1337 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1338 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1341 /* Recover the symbol's offset within the section. */
1342 ofs = (symval - info->tsec->output_section->vma
1343 - info->tsec->output_offset);
1345 /* Look for a GPDISP reloc. */
1346 gpdisp = (elf64_alpha_find_reloc_at_ofs
1347 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1349 if (!gpdisp || gpdisp->r_addend != 4)
1359 /* We've now determined that we can skip an initial gp load. Verify
1360 that the call and the target use the same gp. */
1361 if (info->link_info->hash->creator != info->tsec->owner->xvec
1362 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1369 elf64_alpha_relax_without_lituse (info, symval, irel)
1370 struct alpha_relax_info *info;
1372 Elf_Internal_Rela *irel;
1375 bfd_signed_vma disp;
1377 /* Get the instruction. */
1378 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1380 if (insn >> 26 != OP_LDQ)
1382 ((*_bfd_error_handler)
1383 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1384 bfd_get_filename (info->abfd), info->sec->name,
1385 (unsigned long) irel->r_offset));
1389 /* So we aren't told much. Do what we can with the address load and
1390 fake the rest. All of the optimizations here require that the
1391 offset from the GP fit in 16 bits. */
1393 disp = symval - info->gp;
1394 if (disp < -0x8000 || disp >= 0x8000)
1397 /* On the LITERAL instruction itself, consider exchanging
1398 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1400 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1401 bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
1402 info->changed_contents = true;
1404 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELLOW);
1405 info->changed_relocs = true;
1407 /* Reduce the use count on this got entry by one, possibly
1409 info->gotent->use_count -= 1;
1410 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1412 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1414 /* ??? Search forward through this basic block looking for insns
1415 that use the target register. Stop after an insn modifying the
1416 register is seen, or after a branch or call.
1418 Any such memory load insn may be substituted by a load directly
1419 off the GP. This allows the memory load insn to be issued before
1420 the calculated GP register would otherwise be ready.
1422 Any such jsr insn can be replaced by a bsr if it is in range.
1424 This would mean that we'd have to _add_ relocations, the pain of
1425 which gives one pause. */
1431 elf64_alpha_relax_section (abfd, sec, link_info, again)
1434 struct bfd_link_info *link_info;
1437 Elf_Internal_Shdr *symtab_hdr;
1438 Elf_Internal_Rela *internal_relocs;
1439 Elf_Internal_Rela *free_relocs = NULL;
1440 Elf_Internal_Rela *irel, *irelend;
1441 bfd_byte *free_contents = NULL;
1442 Elf64_External_Sym *extsyms = NULL;
1443 Elf64_External_Sym *free_extsyms = NULL;
1444 struct alpha_elf_got_entry **local_got_entries;
1445 struct alpha_relax_info info;
1447 /* We are not currently changing any sizes, so only one pass. */
1450 if (link_info->relocateable
1451 || (sec->flags & SEC_RELOC) == 0
1452 || sec->reloc_count == 0)
1455 /* If this is the first time we have been called for this section,
1456 initialize the cooked size. */
1457 if (sec->_cooked_size == 0)
1458 sec->_cooked_size = sec->_raw_size;
1460 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1461 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1463 /* Load the relocations for this section. */
1464 internal_relocs = (_bfd_elf64_link_read_relocs
1465 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1466 link_info->keep_memory));
1467 if (internal_relocs == NULL)
1469 if (! link_info->keep_memory)
1470 free_relocs = internal_relocs;
1472 memset(&info, 0, sizeof(info));
1475 info.link_info = link_info;
1476 info.relocs = internal_relocs;
1477 info.relend = irelend = internal_relocs + sec->reloc_count;
1479 /* Find the GP for this object. */
1480 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1483 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1484 info.gp = _bfd_get_gp_value (info.gotobj);
1487 info.gp = (sgot->output_section->vma
1488 + sgot->output_offset
1490 _bfd_set_gp_value (info.gotobj, info.gp);
1494 for (irel = internal_relocs; irel < irelend; irel++)
1497 Elf_Internal_Sym isym;
1498 struct alpha_elf_got_entry *gotent;
1500 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1503 /* Get the section contents. */
1504 if (info.contents == NULL)
1506 if (elf_section_data (sec)->this_hdr.contents != NULL)
1507 info.contents = elf_section_data (sec)->this_hdr.contents;
1510 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1511 if (info.contents == NULL)
1513 free_contents = info.contents;
1515 if (! bfd_get_section_contents (abfd, sec, info.contents,
1516 (file_ptr) 0, sec->_raw_size))
1521 /* Read this BFD's symbols if we haven't done so already. */
1522 if (extsyms == NULL)
1524 if (symtab_hdr->contents != NULL)
1525 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1528 extsyms = ((Elf64_External_Sym *)
1529 bfd_malloc (symtab_hdr->sh_size));
1530 if (extsyms == NULL)
1532 free_extsyms = extsyms;
1533 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1534 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1535 != symtab_hdr->sh_size))
1540 /* Get the value of the symbol referred to by the reloc. */
1541 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1543 /* A local symbol. */
1544 bfd_elf64_swap_symbol_in (abfd,
1545 extsyms + ELF64_R_SYM (irel->r_info),
1547 if (isym.st_shndx == SHN_UNDEF)
1548 info.tsec = bfd_und_section_ptr;
1549 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1550 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1551 else if (isym.st_shndx == SHN_ABS)
1552 info.tsec = bfd_abs_section_ptr;
1553 else if (isym.st_shndx == SHN_COMMON)
1554 info.tsec = bfd_com_section_ptr;
1556 continue; /* who knows. */
1559 info.other = isym.st_other;
1560 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1561 symval = isym.st_value;
1566 struct alpha_elf_link_hash_entry *h;
1568 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1569 h = alpha_elf_sym_hashes (abfd)[indx];
1570 BFD_ASSERT (h != NULL);
1572 while (h->root.root.type == bfd_link_hash_indirect
1573 || h->root.root.type == bfd_link_hash_warning)
1574 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1576 /* We can't do anthing with undefined or dynamic symbols. */
1577 if (h->root.root.type == bfd_link_hash_undefined
1578 || h->root.root.type == bfd_link_hash_undefweak
1579 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1583 info.gotent = gotent;
1584 info.tsec = h->root.root.u.def.section;
1585 info.other = h->root.other;
1586 gotent = h->got_entries;
1587 symval = h->root.root.u.def.value;
1590 /* Search for the got entry to be used by this relocation. */
1591 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1592 gotent = gotent->next;
1593 info.gotent = gotent;
1595 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1596 symval += irel->r_addend;
1598 BFD_ASSERT(info.gotent != NULL);
1600 /* If there exist LITUSE relocations immediately following, this
1601 opens up all sorts of interesting optimizations, because we
1602 now know every location that this address load is used. */
1604 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1606 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1612 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1617 if (!elf64_alpha_size_got_sections (abfd, link_info))
1620 if (info.changed_relocs)
1622 elf_section_data (sec)->relocs = internal_relocs;
1624 else if (free_relocs != NULL)
1629 if (info.changed_contents)
1631 elf_section_data (sec)->this_hdr.contents = info.contents;
1633 else if (free_contents != NULL)
1635 if (! link_info->keep_memory)
1636 free (free_contents);
1639 /* Cache the section contents for elf_link_input_bfd. */
1640 elf_section_data (sec)->this_hdr.contents = info.contents;
1644 if (free_extsyms != NULL)
1646 if (! link_info->keep_memory)
1647 free (free_extsyms);
1650 /* Cache the symbols for elf_link_input_bfd. */
1651 symtab_hdr->contents = extsyms;
1655 *again = info.changed_contents || info.changed_relocs;
1660 if (free_relocs != NULL)
1662 if (free_contents != NULL)
1663 free (free_contents);
1664 if (free_extsyms != NULL)
1665 free (free_extsyms);
1670 #define PLT_HEADER_SIZE 32
1671 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1672 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1673 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1674 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1676 #define PLT_ENTRY_SIZE 12
1677 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1678 #define PLT_ENTRY_WORD2 0
1679 #define PLT_ENTRY_WORD3 0
1681 #define MAX_GOT_ENTRIES (64*1024 / 8)
1683 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1685 /* Handle an Alpha specific section when reading an object file. This
1686 is called when elfcode.h finds a section with an unknown type.
1687 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1691 elf64_alpha_section_from_shdr (abfd, hdr, name)
1693 Elf64_Internal_Shdr *hdr;
1698 /* There ought to be a place to keep ELF backend specific flags, but
1699 at the moment there isn't one. We just keep track of the
1700 sections by their name, instead. Fortunately, the ABI gives
1701 suggested names for all the MIPS specific sections, so we will
1702 probably get away with this. */
1703 switch (hdr->sh_type)
1705 case SHT_ALPHA_DEBUG:
1706 if (strcmp (name, ".mdebug") != 0)
1709 #ifdef ERIC_neverdef
1710 case SHT_ALPHA_REGINFO:
1711 if (strcmp (name, ".reginfo") != 0
1712 || hdr->sh_size != sizeof (Elf64_External_RegInfo))
1720 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1722 newsect = hdr->bfd_section;
1724 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1726 if (! bfd_set_section_flags (abfd, newsect,
1727 (bfd_get_section_flags (abfd, newsect)
1732 #ifdef ERIC_neverdef
1733 /* For a .reginfo section, set the gp value in the tdata information
1734 from the contents of this section. We need the gp value while
1735 processing relocs, so we just get it now. */
1736 if (hdr->sh_type == SHT_ALPHA_REGINFO)
1738 Elf64_External_RegInfo ext;
1741 if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
1742 (file_ptr) 0, sizeof ext))
1744 bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
1745 elf_gp (abfd) = s.ri_gp_value;
1752 /* Set the correct type for an Alpha ELF section. We do this by the
1753 section name, which is a hack, but ought to work. */
1756 elf64_alpha_fake_sections (abfd, hdr, sec)
1758 Elf64_Internal_Shdr *hdr;
1761 register const char *name;
1763 name = bfd_get_section_name (abfd, sec);
1765 if (strcmp (name, ".mdebug") == 0)
1767 hdr->sh_type = SHT_ALPHA_DEBUG;
1768 /* In a shared object on Irix 5.3, the .mdebug section has an
1769 entsize of 0. FIXME: Does this matter? */
1770 if ((abfd->flags & DYNAMIC) != 0 )
1771 hdr->sh_entsize = 0;
1773 hdr->sh_entsize = 1;
1775 #ifdef ERIC_neverdef
1776 else if (strcmp (name, ".reginfo") == 0)
1778 hdr->sh_type = SHT_ALPHA_REGINFO;
1779 /* In a shared object on Irix 5.3, the .reginfo section has an
1780 entsize of 0x18. FIXME: Does this matter? */
1781 if ((abfd->flags & DYNAMIC) != 0)
1782 hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
1784 hdr->sh_entsize = 1;
1786 /* Force the section size to the correct value, even if the
1787 linker thinks it is larger. The link routine below will only
1788 write out this much data for .reginfo. */
1789 hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
1791 else if (strcmp (name, ".hash") == 0
1792 || strcmp (name, ".dynamic") == 0
1793 || strcmp (name, ".dynstr") == 0)
1795 hdr->sh_entsize = 0;
1796 hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
1799 else if (strcmp (name, ".sdata") == 0
1800 || strcmp (name, ".sbss") == 0
1801 || strcmp (name, ".lit4") == 0
1802 || strcmp (name, ".lit8") == 0)
1803 hdr->sh_flags |= SHF_ALPHA_GPREL;
1808 /* Hook called by the linker routine which adds symbols from an object
1809 file. We use it to put .comm items in .sbss, and not .bss. */
1812 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1814 struct bfd_link_info *info;
1815 const Elf_Internal_Sym *sym;
1821 if (sym->st_shndx == SHN_COMMON
1822 && !info->relocateable
1823 && sym->st_size <= bfd_get_gp_size (abfd))
1825 /* Common symbols less than or equal to -G nn bytes are
1826 automatically put into .sbss. */
1828 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1832 scomm = bfd_make_section (abfd, ".scommon");
1834 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1836 | SEC_LINKER_CREATED)))
1841 *valp = sym->st_size;
1847 /* Create the .got section. */
1850 elf64_alpha_create_got_section(abfd, info)
1852 struct bfd_link_info *info;
1856 if (bfd_get_section_by_name (abfd, ".got"))
1859 s = bfd_make_section (abfd, ".got");
1861 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1864 | SEC_LINKER_CREATED))
1865 || !bfd_set_section_alignment (abfd, s, 3))
1868 alpha_elf_tdata (abfd)->got = s;
1873 /* Create all the dynamic sections. */
1876 elf64_alpha_create_dynamic_sections (abfd, info)
1878 struct bfd_link_info *info;
1881 struct elf_link_hash_entry *h;
1883 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1885 s = bfd_make_section (abfd, ".plt");
1887 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1890 | SEC_LINKER_CREATED
1892 || ! bfd_set_section_alignment (abfd, s, 3))
1895 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1898 if (! (_bfd_generic_link_add_one_symbol
1899 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1900 (bfd_vma) 0, (const char *) NULL, false,
1901 get_elf_backend_data (abfd)->collect,
1902 (struct bfd_link_hash_entry **) &h)))
1904 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1905 h->type = STT_OBJECT;
1908 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1911 s = bfd_make_section (abfd, ".rela.plt");
1913 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1916 | SEC_LINKER_CREATED
1918 || ! bfd_set_section_alignment (abfd, s, 3))
1921 /* We may or may not have created a .got section for this object, but
1922 we definitely havn't done the rest of the work. */
1924 if (!elf64_alpha_create_got_section (abfd, info))
1927 s = bfd_make_section(abfd, ".rela.got");
1929 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1932 | SEC_LINKER_CREATED
1934 || !bfd_set_section_alignment (abfd, s, 3))
1937 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1938 dynobj's .got section. We don't do this in the linker script
1939 because we don't want to define the symbol if we are not creating
1940 a global offset table. */
1942 if (!(_bfd_generic_link_add_one_symbol
1943 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1944 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1945 false, get_elf_backend_data (abfd)->collect,
1946 (struct bfd_link_hash_entry **) &h)))
1948 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1949 h->type = STT_OBJECT;
1952 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1955 elf_hash_table (info)->hgot = h;
1960 /* Read ECOFF debugging information from a .mdebug section into a
1961 ecoff_debug_info structure. */
1964 elf64_alpha_read_ecoff_info (abfd, section, debug)
1967 struct ecoff_debug_info *debug;
1970 const struct ecoff_debug_swap *swap;
1971 char *ext_hdr = NULL;
1973 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1974 memset (debug, 0, sizeof(*debug));
1976 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
1977 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1980 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1981 swap->external_hdr_size)
1985 symhdr = &debug->symbolic_header;
1986 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1988 /* The symbolic header contains absolute file offsets and sizes to
1990 #define READ(ptr, offset, count, size, type) \
1991 if (symhdr->count == 0) \
1992 debug->ptr = NULL; \
1995 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
1996 if (debug->ptr == NULL) \
1997 goto error_return; \
1998 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1999 || (bfd_read (debug->ptr, size, symhdr->count, \
2000 abfd) != size * symhdr->count)) \
2001 goto error_return; \
2004 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
2005 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
2006 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
2007 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
2008 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2009 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2011 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2012 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2013 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2014 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2015 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2019 debug->adjust = NULL;
2024 if (ext_hdr != NULL)
2026 if (debug->line != NULL)
2028 if (debug->external_dnr != NULL)
2029 free (debug->external_dnr);
2030 if (debug->external_pdr != NULL)
2031 free (debug->external_pdr);
2032 if (debug->external_sym != NULL)
2033 free (debug->external_sym);
2034 if (debug->external_opt != NULL)
2035 free (debug->external_opt);
2036 if (debug->external_aux != NULL)
2037 free (debug->external_aux);
2038 if (debug->ss != NULL)
2040 if (debug->ssext != NULL)
2041 free (debug->ssext);
2042 if (debug->external_fdr != NULL)
2043 free (debug->external_fdr);
2044 if (debug->external_rfd != NULL)
2045 free (debug->external_rfd);
2046 if (debug->external_ext != NULL)
2047 free (debug->external_ext);
2051 /* Alpha ELF local labels start with '$'. */
2054 elf64_alpha_is_local_label_name (abfd, name)
2058 return name[0] == '$';
2061 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2062 routine in order to handle the ECOFF debugging information. We
2063 still call this mips_elf_find_line because of the slot
2064 find_line_info in elf_obj_tdata is declared that way. */
2066 struct mips_elf_find_line
2068 struct ecoff_debug_info d;
2069 struct ecoff_find_line i;
2073 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2074 functionname_ptr, line_ptr)
2079 const char **filename_ptr;
2080 const char **functionname_ptr;
2081 unsigned int *line_ptr;
2085 msec = bfd_get_section_by_name (abfd, ".mdebug");
2089 struct mips_elf_find_line *fi;
2090 const struct ecoff_debug_swap * const swap =
2091 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2093 /* If we are called during a link, alpha_elf_final_link may have
2094 cleared the SEC_HAS_CONTENTS field. We force it back on here
2095 if appropriate (which it normally will be). */
2096 origflags = msec->flags;
2097 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2098 msec->flags |= SEC_HAS_CONTENTS;
2100 fi = elf_tdata (abfd)->find_line_info;
2103 bfd_size_type external_fdr_size;
2106 struct fdr *fdr_ptr;
2108 fi = ((struct mips_elf_find_line *)
2109 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2112 msec->flags = origflags;
2116 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2118 msec->flags = origflags;
2122 /* Swap in the FDR information. */
2123 fi->d.fdr = ((struct fdr *)
2125 (fi->d.symbolic_header.ifdMax *
2126 sizeof (struct fdr))));
2127 if (fi->d.fdr == NULL)
2129 msec->flags = origflags;
2132 external_fdr_size = swap->external_fdr_size;
2133 fdr_ptr = fi->d.fdr;
2134 fraw_src = (char *) fi->d.external_fdr;
2135 fraw_end = (fraw_src
2136 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2137 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2138 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2140 elf_tdata (abfd)->find_line_info = fi;
2142 /* Note that we don't bother to ever free this information.
2143 find_nearest_line is either called all the time, as in
2144 objdump -l, so the information should be saved, or it is
2145 rarely called, as in ld error messages, so the memory
2146 wasted is unimportant. Still, it would probably be a
2147 good idea for free_cached_info to throw it away. */
2150 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2151 &fi->i, filename_ptr, functionname_ptr,
2154 msec->flags = origflags;
2158 msec->flags = origflags;
2161 /* Fall back on the generic ELF find_nearest_line routine. */
2163 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2164 filename_ptr, functionname_ptr,
2168 /* Structure used to pass information to alpha_elf_output_extsym. */
2173 struct bfd_link_info *info;
2174 struct ecoff_debug_info *debug;
2175 const struct ecoff_debug_swap *swap;
2180 elf64_alpha_output_extsym (h, data)
2181 struct alpha_elf_link_hash_entry *h;
2184 struct extsym_info *einfo = (struct extsym_info *) data;
2186 asection *sec, *output_section;
2188 if (h->root.indx == -2)
2190 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2191 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2192 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2193 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2195 else if (einfo->info->strip == strip_all
2196 || (einfo->info->strip == strip_some
2197 && bfd_hash_lookup (einfo->info->keep_hash,
2198 h->root.root.root.string,
2199 false, false) == NULL))
2207 if (h->esym.ifd == -2)
2210 h->esym.cobol_main = 0;
2211 h->esym.weakext = 0;
2212 h->esym.reserved = 0;
2213 h->esym.ifd = ifdNil;
2214 h->esym.asym.value = 0;
2215 h->esym.asym.st = stGlobal;
2217 if (h->root.root.type != bfd_link_hash_defined
2218 && h->root.root.type != bfd_link_hash_defweak)
2219 h->esym.asym.sc = scAbs;
2224 sec = h->root.root.u.def.section;
2225 output_section = sec->output_section;
2227 /* When making a shared library and symbol h is the one from
2228 the another shared library, OUTPUT_SECTION may be null. */
2229 if (output_section == NULL)
2230 h->esym.asym.sc = scUndefined;
2233 name = bfd_section_name (output_section->owner, output_section);
2235 if (strcmp (name, ".text") == 0)
2236 h->esym.asym.sc = scText;
2237 else if (strcmp (name, ".data") == 0)
2238 h->esym.asym.sc = scData;
2239 else if (strcmp (name, ".sdata") == 0)
2240 h->esym.asym.sc = scSData;
2241 else if (strcmp (name, ".rodata") == 0
2242 || strcmp (name, ".rdata") == 0)
2243 h->esym.asym.sc = scRData;
2244 else if (strcmp (name, ".bss") == 0)
2245 h->esym.asym.sc = scBss;
2246 else if (strcmp (name, ".sbss") == 0)
2247 h->esym.asym.sc = scSBss;
2248 else if (strcmp (name, ".init") == 0)
2249 h->esym.asym.sc = scInit;
2250 else if (strcmp (name, ".fini") == 0)
2251 h->esym.asym.sc = scFini;
2253 h->esym.asym.sc = scAbs;
2257 h->esym.asym.reserved = 0;
2258 h->esym.asym.index = indexNil;
2261 if (h->root.root.type == bfd_link_hash_common)
2262 h->esym.asym.value = h->root.root.u.c.size;
2263 else if (h->root.root.type == bfd_link_hash_defined
2264 || h->root.root.type == bfd_link_hash_defweak)
2266 if (h->esym.asym.sc == scCommon)
2267 h->esym.asym.sc = scBss;
2268 else if (h->esym.asym.sc == scSCommon)
2269 h->esym.asym.sc = scSBss;
2271 sec = h->root.root.u.def.section;
2272 output_section = sec->output_section;
2273 if (output_section != NULL)
2274 h->esym.asym.value = (h->root.root.u.def.value
2275 + sec->output_offset
2276 + output_section->vma);
2278 h->esym.asym.value = 0;
2280 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2282 /* Set type and value for a symbol with a function stub. */
2283 h->esym.asym.st = stProc;
2284 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2286 h->esym.asym.value = 0;
2289 output_section = sec->output_section;
2290 if (output_section != NULL)
2291 h->esym.asym.value = (h->root.plt.offset
2292 + sec->output_offset
2293 + output_section->vma);
2295 h->esym.asym.value = 0;
2302 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2303 h->root.root.root.string,
2306 einfo->failed = true;
2313 /* FIXME: Create a runtime procedure table from the .mdebug section.
2316 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2319 struct bfd_link_info *info;
2321 struct ecoff_debug_info *debug;
2324 /* Handle dynamic relocations when doing an Alpha ELF link. */
2327 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2329 struct bfd_link_info *info;
2331 const Elf_Internal_Rela *relocs;
2335 const char *rel_sec_name;
2336 Elf_Internal_Shdr *symtab_hdr;
2337 struct alpha_elf_link_hash_entry **sym_hashes;
2338 struct alpha_elf_got_entry **local_got_entries;
2339 const Elf_Internal_Rela *rel, *relend;
2342 if (info->relocateable)
2345 dynobj = elf_hash_table(info)->dynobj;
2347 elf_hash_table(info)->dynobj = dynobj = abfd;
2350 rel_sec_name = NULL;
2351 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2352 sym_hashes = alpha_elf_sym_hashes(abfd);
2353 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2356 relend = relocs + sec->reloc_count;
2357 for (rel = relocs; rel < relend; ++rel)
2359 unsigned long r_symndx, r_type;
2360 struct alpha_elf_link_hash_entry *h;
2362 r_symndx = ELF64_R_SYM (rel->r_info);
2363 if (r_symndx < symtab_hdr->sh_info)
2367 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2369 while (h->root.root.type == bfd_link_hash_indirect
2370 || h->root.root.type == bfd_link_hash_warning)
2371 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2373 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2375 r_type = ELF64_R_TYPE (rel->r_info);
2379 case R_ALPHA_LITERAL:
2381 struct alpha_elf_got_entry *gotent;
2386 /* Search for and possibly create a got entry. */
2387 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2388 if (gotent->gotobj == abfd &&
2389 gotent->addend == rel->r_addend)
2394 gotent = ((struct alpha_elf_got_entry *)
2396 sizeof (struct alpha_elf_got_entry)));
2400 gotent->gotobj = abfd;
2401 gotent->addend = rel->r_addend;
2402 gotent->got_offset = -1;
2404 gotent->use_count = 1;
2406 gotent->next = h->got_entries;
2407 h->got_entries = gotent;
2409 alpha_elf_tdata (abfd)->total_got_entries++;
2412 gotent->use_count += 1;
2416 /* This is a local .got entry -- record for merge. */
2417 if (!local_got_entries)
2420 size = (symtab_hdr->sh_info
2421 * sizeof (struct alpha_elf_got_entry *));
2423 local_got_entries = ((struct alpha_elf_got_entry **)
2424 bfd_alloc (abfd, size));
2425 if (!local_got_entries)
2428 memset (local_got_entries, 0, size);
2429 alpha_elf_tdata (abfd)->local_got_entries =
2433 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2434 gotent != NULL && gotent->addend != rel->r_addend;
2435 gotent = gotent->next)
2439 gotent = ((struct alpha_elf_got_entry *)
2441 sizeof (struct alpha_elf_got_entry)));
2445 gotent->gotobj = abfd;
2446 gotent->addend = rel->r_addend;
2447 gotent->got_offset = -1;
2449 gotent->use_count = 1;
2451 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2452 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2454 alpha_elf_tdata(abfd)->total_got_entries++;
2455 alpha_elf_tdata(abfd)->n_local_got_entries++;
2458 gotent->use_count += 1;
2461 /* Remember how this literal is used from its LITUSEs.
2462 This will be important when it comes to decide if we can
2463 create a .plt entry for a function symbol. */
2465 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2470 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2471 flags |= 1 << rel->r_addend;
2473 while (rel+1 < relend &&
2474 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2478 /* No LITUSEs -- presumably the address is not being
2479 loaded for nothing. */
2480 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2483 gotent->flags |= flags;
2486 /* Make a guess as to whether a .plt entry will be needed. */
2487 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2488 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2490 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2495 case R_ALPHA_GPDISP:
2496 case R_ALPHA_GPREL32:
2497 case R_ALPHA_GPRELHIGH:
2498 case R_ALPHA_GPRELLOW:
2499 /* We don't actually use the .got here, but the sections must
2500 be created before the linker maps input sections to output
2504 if (!elf64_alpha_create_got_section (abfd, info))
2507 /* Make sure the object's gotobj is set to itself so
2508 that we default to every object with its own .got.
2509 We'll merge .gots later once we've collected each
2511 alpha_elf_tdata(abfd)->gotobj = abfd;
2517 case R_ALPHA_SREL16:
2518 case R_ALPHA_SREL32:
2519 case R_ALPHA_SREL64:
2524 case R_ALPHA_REFLONG:
2525 case R_ALPHA_REFQUAD:
2526 if (rel_sec_name == NULL)
2528 rel_sec_name = (bfd_elf_string_from_elf_section
2529 (abfd, elf_elfheader(abfd)->e_shstrndx,
2530 elf_section_data(sec)->rel_hdr.sh_name));
2531 if (rel_sec_name == NULL)
2534 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2535 && strcmp (bfd_get_section_name (abfd, sec),
2536 rel_sec_name+5) == 0);
2539 /* We need to create the section here now whether we eventually
2540 use it or not so that it gets mapped to an output section by
2541 the linker. If not used, we'll kill it in
2542 size_dynamic_sections. */
2545 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2548 sreloc = bfd_make_section (dynobj, rel_sec_name);
2550 || !bfd_set_section_flags (dynobj, sreloc,
2554 | SEC_LINKER_CREATED
2556 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2563 /* Since we havn't seen all of the input symbols yet, we
2564 don't know whether we'll actually need a dynamic relocation
2565 entry for this reloc. So make a record of it. Once we
2566 find out if this thing needs dynamic relocation we'll
2567 expand the relocation sections by the appropriate amount. */
2569 struct alpha_elf_reloc_entry *rent;
2571 for (rent = h->reloc_entries; rent; rent = rent->next)
2572 if (rent->rtype == r_type && rent->srel == sreloc)
2577 rent = ((struct alpha_elf_reloc_entry *)
2579 sizeof (struct alpha_elf_reloc_entry)));
2583 rent->srel = sreloc;
2584 rent->rtype = r_type;
2587 rent->next = h->reloc_entries;
2588 h->reloc_entries = rent;
2593 else if (info->shared && (sec->flags & SEC_ALLOC))
2595 /* If this is a shared library, and the section is to be
2596 loaded into memory, we need a RELATIVE reloc. */
2597 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2606 /* Adjust a symbol defined by a dynamic object and referenced by a
2607 regular object. The current definition is in some section of the
2608 dynamic object, but we're not including those sections. We have to
2609 change the definition to something the rest of the link can
2613 elf64_alpha_adjust_dynamic_symbol (info, h)
2614 struct bfd_link_info *info;
2615 struct elf_link_hash_entry *h;
2619 struct alpha_elf_link_hash_entry *ah;
2621 dynobj = elf_hash_table(info)->dynobj;
2622 ah = (struct alpha_elf_link_hash_entry *)h;
2624 /* Now that we've seen all of the input symbols, finalize our decision
2625 about whether this symbol should get a .plt entry. */
2627 if (h->root.type != bfd_link_hash_undefweak
2628 && alpha_elf_dynamic_symbol_p (h, info)
2629 && ((h->type == STT_FUNC
2630 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2631 || (h->type == STT_NOTYPE
2632 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2633 /* Don't prevent otherwise valid programs from linking by attempting
2634 to create a new .got entry somewhere. A Correct Solution would be
2635 to add a new .got section to a new object file and let it be merged
2636 somewhere later. But for now don't bother. */
2639 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2641 s = bfd_get_section_by_name(dynobj, ".plt");
2642 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2645 /* The first bit of the .plt is reserved. */
2646 if (s->_raw_size == 0)
2647 s->_raw_size = PLT_HEADER_SIZE;
2649 h->plt.offset = s->_raw_size;
2650 s->_raw_size += PLT_ENTRY_SIZE;
2652 /* If this symbol is not defined in a regular file, and we are not
2653 generating a shared library, then set the symbol to the location
2654 in the .plt. This is required to make function pointers compare
2655 equal between the normal executable and the shared library. */
2657 && h->root.type != bfd_link_hash_defweak)
2659 h->root.u.def.section = s;
2660 h->root.u.def.value = h->plt.offset;
2663 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2664 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2665 BFD_ASSERT (s != NULL);
2666 s->_raw_size += sizeof (Elf64_External_Rela);
2671 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2673 /* If this is a weak symbol, and there is a real definition, the
2674 processor independent code will have arranged for us to see the
2675 real definition first, and we can just use the same value. */
2676 if (h->weakdef != NULL)
2678 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2679 || h->weakdef->root.type == bfd_link_hash_defweak);
2680 h->root.u.def.section = h->weakdef->root.u.def.section;
2681 h->root.u.def.value = h->weakdef->root.u.def.value;
2685 /* This is a reference to a symbol defined by a dynamic object which
2686 is not a function. The Alpha, since it uses .got entries for all
2687 symbols even in regular objects, does not need the hackery of a
2688 .dynbss section and COPY dynamic relocations. */
2693 /* Symbol versioning can create new symbols, and make our old symbols
2694 indirect to the new ones. Consolidate the got and reloc information
2695 in these situations. */
2698 elf64_alpha_merge_ind_symbols (hi, dummy)
2699 struct alpha_elf_link_hash_entry *hi;
2702 struct alpha_elf_link_hash_entry *hs;
2704 if (hi->root.root.type != bfd_link_hash_indirect)
2708 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2709 } while (hs->root.root.type == bfd_link_hash_indirect);
2711 /* Merge the flags. Whee. */
2713 hs->flags |= hi->flags;
2715 /* Merge the .got entries. Cannibalize the old symbol's list in
2716 doing so, since we don't need it anymore. */
2718 if (hs->got_entries == NULL)
2719 hs->got_entries = hi->got_entries;
2722 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2724 gsh = hs->got_entries;
2725 for (gi = hi->got_entries; gi ; gi = gin)
2728 for (gs = gsh; gs ; gs = gs->next)
2729 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2731 gi->next = hs->got_entries;
2732 hs->got_entries = gi;
2736 hi->got_entries = NULL;
2738 /* And similar for the reloc entries. */
2740 if (hs->reloc_entries == NULL)
2741 hs->reloc_entries = hi->reloc_entries;
2744 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2746 rsh = hs->reloc_entries;
2747 for (ri = hi->reloc_entries; ri ; ri = rin)
2750 for (rs = rsh; rs ; rs = rs->next)
2751 if (ri->rtype == rs->rtype)
2753 rs->count += ri->count;
2756 ri->next = hs->reloc_entries;
2757 hs->reloc_entries = ri;
2761 hi->reloc_entries = NULL;
2766 /* Is it possible to merge two object file's .got tables? */
2769 elf64_alpha_can_merge_gots (a, b)
2772 int total = alpha_elf_tdata (a)->total_got_entries;
2775 /* Trivial quick fallout test. */
2776 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2779 /* By their nature, local .got entries cannot be merged. */
2780 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2783 /* Failing the common trivial comparison, we must effectively
2784 perform the merge. Not actually performing the merge means that
2785 we don't have to store undo information in case we fail. */
2786 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2788 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2789 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2792 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2793 for (i = 0; i < n; ++i)
2795 struct alpha_elf_got_entry *ae, *be;
2796 struct alpha_elf_link_hash_entry *h;
2799 while (h->root.root.type == bfd_link_hash_indirect
2800 || h->root.root.type == bfd_link_hash_warning)
2801 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2803 for (be = h->got_entries; be ; be = be->next)
2805 if (be->use_count == 0)
2807 if (be->gotobj != b)
2810 for (ae = h->got_entries; ae ; ae = ae->next)
2811 if (ae->gotobj == a && ae->addend == be->addend)
2814 if (++total > MAX_GOT_ENTRIES)
2824 /* Actually merge two .got tables. */
2827 elf64_alpha_merge_gots (a, b)
2830 int total = alpha_elf_tdata (a)->total_got_entries;
2833 /* Remember local expansion. */
2835 int e = alpha_elf_tdata (b)->n_local_got_entries;
2837 alpha_elf_tdata (a)->n_local_got_entries += e;
2840 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2842 struct alpha_elf_got_entry **local_got_entries;
2843 struct alpha_elf_link_hash_entry **hashes;
2844 Elf_Internal_Shdr *symtab_hdr;
2847 /* Let the local .got entries know they are part of a new subsegment. */
2848 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2849 if (local_got_entries)
2851 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2852 for (i = 0; i < n; ++i)
2854 struct alpha_elf_got_entry *ent;
2855 for (ent = local_got_entries[i]; ent; ent = ent->next)
2860 /* Merge the global .got entries. */
2861 hashes = alpha_elf_sym_hashes (bsub);
2862 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2864 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2865 for (i = 0; i < n; ++i)
2867 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2868 struct alpha_elf_link_hash_entry *h;
2871 while (h->root.root.type == bfd_link_hash_indirect
2872 || h->root.root.type == bfd_link_hash_warning)
2873 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2875 start = &h->got_entries;
2876 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2878 if (be->use_count == 0)
2883 if (be->gotobj != b)
2886 for (ae = *start; ae ; ae = ae->next)
2887 if (ae->gotobj == a && ae->addend == be->addend)
2889 ae->flags |= be->flags;
2890 ae->use_count += be->use_count;
2901 alpha_elf_tdata (bsub)->gotobj = a;
2903 alpha_elf_tdata (a)->total_got_entries = total;
2905 /* Merge the two in_got chains. */
2910 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2913 alpha_elf_tdata (bsub)->in_got_link_next = b;
2917 /* Calculate the offsets for the got entries. */
2920 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2921 struct alpha_elf_link_hash_entry *h;
2924 struct alpha_elf_got_entry *gotent;
2926 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2927 if (gotent->use_count > 0)
2930 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2932 gotent->got_offset = *plge;
2940 elf64_alpha_calc_got_offsets (info)
2941 struct bfd_link_info *info;
2943 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2945 /* First, zero out the .got sizes, as we may be recalculating the
2946 .got after optimizing it. */
2947 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2948 alpha_elf_tdata(i)->got->_raw_size = 0;
2950 /* Next, fill in the offsets for all the global entries. */
2951 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2952 elf64_alpha_calc_got_offsets_for_symbol,
2955 /* Finally, fill in the offsets for the local entries. */
2956 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2958 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2961 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2963 struct alpha_elf_got_entry **local_got_entries, *gotent;
2966 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2967 if (!local_got_entries)
2970 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2971 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2972 if (gotent->use_count > 0)
2974 gotent->got_offset = got_offset;
2979 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2980 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2984 /* Constructs the gots. */
2987 elf64_alpha_size_got_sections (output_bfd, info)
2989 struct bfd_link_info *info;
2991 bfd *i, *got_list, *cur_got_obj;
2992 int something_changed = 0;
2994 got_list = alpha_elf_hash_table (info)->got_list;
2996 /* On the first time through, pretend we have an existing got list
2997 consisting of all of the input files. */
2998 if (got_list == NULL)
3000 for (i = info->input_bfds; i ; i = i->link_next)
3002 bfd *this_got = alpha_elf_tdata (i)->gotobj;
3003 if (this_got == NULL)
3006 /* We are assuming no merging has yet ocurred. */
3007 BFD_ASSERT (this_got == i);
3009 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
3011 /* Yikes! A single object file has too many entries. */
3012 (*_bfd_error_handler)
3013 (_("%s: .got subsegment exceeds 64K (size %d)"),
3014 bfd_get_filename (i),
3015 alpha_elf_tdata (this_got)->total_got_entries * 8);
3019 if (got_list == NULL)
3020 got_list = this_got;
3022 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3023 cur_got_obj = this_got;
3026 /* Strange degenerate case of no got references. */
3027 if (got_list == NULL)
3030 alpha_elf_hash_table (info)->got_list = got_list;
3032 /* Force got offsets to be recalculated. */
3033 something_changed = 1;
3036 cur_got_obj = got_list;
3037 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3040 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3042 elf64_alpha_merge_gots (cur_got_obj, i);
3043 i = alpha_elf_tdata(i)->got_link_next;
3044 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3045 something_changed = 1;
3050 i = alpha_elf_tdata(i)->got_link_next;
3054 /* Once the gots have been merged, fill in the got offsets for
3055 everything therein. */
3056 if (1 || something_changed)
3057 elf64_alpha_calc_got_offsets (info);
3063 elf64_alpha_always_size_sections (output_bfd, info)
3065 struct bfd_link_info *info;
3069 if (info->relocateable)
3072 /* First, take care of the indirect symbols created by versioning. */
3073 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3074 elf64_alpha_merge_ind_symbols,
3077 if (!elf64_alpha_size_got_sections (output_bfd, info))
3080 /* Allocate space for all of the .got subsections. */
3081 i = alpha_elf_hash_table (info)->got_list;
3082 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3084 asection *s = alpha_elf_tdata(i)->got;
3085 if (s->_raw_size > 0)
3087 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3088 if (s->contents == NULL)
3096 /* Work out the sizes of the dynamic relocation entries. */
3099 elf64_alpha_calc_dynrel_sizes (h, info)
3100 struct alpha_elf_link_hash_entry *h;
3101 struct bfd_link_info *info;
3103 /* If the symbol was defined as a common symbol in a regular object
3104 file, and there was no definition in any dynamic object, then the
3105 linker will have allocated space for the symbol in a common
3106 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3107 set. This is done for dynamic symbols in
3108 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3109 symbols, somehow. */
3110 if (((h->root.elf_link_hash_flags
3111 & (ELF_LINK_HASH_DEF_REGULAR
3112 | ELF_LINK_HASH_REF_REGULAR
3113 | ELF_LINK_HASH_DEF_DYNAMIC))
3114 == ELF_LINK_HASH_REF_REGULAR)
3115 && (h->root.root.type == bfd_link_hash_defined
3116 || h->root.root.type == bfd_link_hash_defweak)
3117 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3119 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3122 /* If the symbol is dynamic, we'll need all the relocations in their
3123 natural form. If this is a shared object, and it has been forced
3124 local, we'll need the same number of RELATIVE relocations. */
3126 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3128 struct alpha_elf_reloc_entry *relent;
3130 struct alpha_elf_got_entry *gotent;
3131 bfd_size_type count;
3134 for (relent = h->reloc_entries; relent; relent = relent->next)
3135 if (relent->rtype == R_ALPHA_REFLONG
3136 || relent->rtype == R_ALPHA_REFQUAD)
3138 relent->srel->_raw_size +=
3139 sizeof(Elf64_External_Rela) * relent->count;
3142 dynobj = elf_hash_table(info)->dynobj;
3145 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3148 /* If we are using a .plt entry, subtract one, as the first
3149 reference uses a .rela.plt entry instead. */
3150 if (h->root.plt.offset != MINUS_ONE)
3155 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3156 BFD_ASSERT (srel != NULL);
3157 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3164 /* Set the sizes of the dynamic sections. */
3167 elf64_alpha_size_dynamic_sections (output_bfd, info)
3169 struct bfd_link_info *info;
3176 dynobj = elf_hash_table(info)->dynobj;
3177 BFD_ASSERT(dynobj != NULL);
3179 if (elf_hash_table (info)->dynamic_sections_created)
3181 /* Set the contents of the .interp section to the interpreter. */
3184 s = bfd_get_section_by_name (dynobj, ".interp");
3185 BFD_ASSERT (s != NULL);
3186 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3187 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3190 /* Now that we've seen all of the input files, we can decide which
3191 symbols need dynamic relocation entries and which don't. We've
3192 collected information in check_relocs that we can now apply to
3193 size the dynamic relocation sections. */
3194 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3195 elf64_alpha_calc_dynrel_sizes,
3198 /* When building shared libraries, each local .got entry needs a
3204 bfd_size_type count;
3206 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3207 BFD_ASSERT (srel != NULL);
3209 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3211 i = alpha_elf_tdata(i)->got_link_next)
3212 count += alpha_elf_tdata(i)->n_local_got_entries;
3214 srel->_raw_size += count * sizeof(Elf64_External_Rela);
3217 /* else we're not dynamic and by definition we don't need such things. */
3219 /* The check_relocs and adjust_dynamic_symbol entry points have
3220 determined the sizes of the various dynamic sections. Allocate
3224 for (s = dynobj->sections; s != NULL; s = s->next)
3229 if (!(s->flags & SEC_LINKER_CREATED))
3232 /* It's OK to base decisions on the section name, because none
3233 of the dynobj section names depend upon the input files. */
3234 name = bfd_get_section_name (dynobj, s);
3236 /* If we don't need this section, strip it from the output file.
3237 This is to handle .rela.bss and .rela.plt. We must create it
3238 in create_dynamic_sections, because it must be created before
3239 the linker maps input sections to output sections. The
3240 linker does that before adjust_dynamic_symbol is called, and
3241 it is that function which decides whether anything needs to
3242 go into these sections. */
3246 if (strncmp (name, ".rela", 5) == 0)
3248 strip = (s->_raw_size == 0);
3252 const char *outname;
3255 /* If this relocation section applies to a read only
3256 section, then we probably need a DT_TEXTREL entry. */
3257 outname = bfd_get_section_name (output_bfd,
3259 target = bfd_get_section_by_name (output_bfd, outname + 5);
3261 && (target->flags & SEC_READONLY) != 0
3262 && (target->flags & SEC_ALLOC) != 0)
3265 if (strcmp(name, ".rela.plt") == 0)
3268 /* We use the reloc_count field as a counter if we need
3269 to copy relocs into the output file. */
3273 else if (strcmp (name, ".plt") != 0)
3275 /* It's not one of our dynamic sections, so don't allocate space. */
3280 _bfd_strip_section_from_output (info, s);
3283 /* Allocate memory for the section contents. */
3284 s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3285 if (s->contents == NULL && s->_raw_size != 0)
3290 if (elf_hash_table (info)->dynamic_sections_created)
3292 /* Add some entries to the .dynamic section. We fill in the
3293 values later, in elf64_alpha_finish_dynamic_sections, but we
3294 must add the entries now so that we get the correct size for
3295 the .dynamic section. The DT_DEBUG entry is filled in by the
3296 dynamic linker and used by the debugger. */
3299 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3303 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3308 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3309 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3310 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3314 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3315 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3316 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3317 sizeof(Elf64_External_Rela)))
3322 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3324 info->flags |= DF_TEXTREL;
3331 /* Relocate an Alpha ELF section. */
3334 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3335 contents, relocs, local_syms, local_sections)
3337 struct bfd_link_info *info;
3339 asection *input_section;
3341 Elf_Internal_Rela *relocs;
3342 Elf_Internal_Sym *local_syms;
3343 asection **local_sections;
3345 Elf_Internal_Shdr *symtab_hdr;
3346 Elf_Internal_Rela *rel;
3347 Elf_Internal_Rela *relend;
3348 asection *sec, *sgot, *srel, *srelgot;
3349 bfd *dynobj, *gotobj;
3352 srelgot = srel = NULL;
3353 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3354 dynobj = elf_hash_table (info)->dynobj;
3357 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3360 /* Find the gp value for this input bfd. */
3363 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3366 sgot = alpha_elf_tdata (gotobj)->got;
3367 gp = _bfd_get_gp_value (gotobj);
3370 gp = (sgot->output_section->vma
3371 + sgot->output_offset
3373 _bfd_set_gp_value (gotobj, gp);
3378 relend = relocs + input_section->reloc_count;
3379 for (; rel < relend; rel++)
3382 reloc_howto_type *howto;
3383 unsigned long r_symndx;
3384 struct alpha_elf_link_hash_entry *h;
3385 Elf_Internal_Sym *sym;
3388 bfd_reloc_status_type r;
3390 r_type = ELF64_R_TYPE(rel->r_info);
3391 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3393 bfd_set_error (bfd_error_bad_value);
3396 howto = elf64_alpha_howto_table + r_type;
3398 r_symndx = ELF64_R_SYM(rel->r_info);
3400 if (info->relocateable)
3402 /* This is a relocateable link. We don't have to change
3403 anything, unless the reloc is against a section symbol,
3404 in which case we have to adjust according to where the
3405 section symbol winds up in the output section. */
3407 /* The symbol associated with GPDISP and LITUSE is
3408 immaterial. Only the addend is significant. */
3409 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3412 if (r_symndx < symtab_hdr->sh_info)
3414 sym = local_syms + r_symndx;
3415 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3417 sec = local_sections[r_symndx];
3418 rel->r_addend += sec->output_offset + sym->st_value;
3425 /* This is a final link. */
3431 if (r_symndx < symtab_hdr->sh_info)
3433 sym = local_syms + r_symndx;
3434 sec = local_sections[r_symndx];
3435 relocation = (sec->output_section->vma
3436 + sec->output_offset
3441 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3443 while (h->root.root.type == bfd_link_hash_indirect
3444 || h->root.root.type == bfd_link_hash_warning)
3445 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3447 if (h->root.root.type == bfd_link_hash_defined
3448 || h->root.root.type == bfd_link_hash_defweak)
3450 sec = h->root.root.u.def.section;
3453 if ((r_type == R_ALPHA_LITERAL
3454 && elf_hash_table(info)->dynamic_sections_created
3457 || !(h->root.elf_link_hash_flags
3458 & ELF_LINK_HASH_DEF_REGULAR)))
3461 || !(h->root.elf_link_hash_flags
3462 & ELF_LINK_HASH_DEF_REGULAR))
3463 && (input_section->flags & SEC_ALLOC)
3464 && (r_type == R_ALPHA_REFLONG
3465 || r_type == R_ALPHA_REFQUAD
3466 || r_type == R_ALPHA_LITERAL)))
3468 /* In these cases, we don't need the relocation value.
3469 We check specially because in some obscure cases
3470 sec->output_section will be NULL. */
3474 /* FIXME: Are not these obscure cases simply bugs? Let's
3475 get something working and come back to this. */
3476 if (sec->output_section == NULL)
3478 #endif /* rth_notdef */
3481 relocation = (h->root.root.u.def.value
3482 + sec->output_section->vma
3483 + sec->output_offset);
3486 else if (h->root.root.type == bfd_link_hash_undefweak)
3488 else if (info->shared && !info->symbolic
3489 && !info->no_undefined
3490 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3494 if (!((*info->callbacks->undefined_symbol)
3495 (info, h->root.root.root.string, input_bfd,
3496 input_section, rel->r_offset,
3497 (!info->shared || info->no_undefined
3498 || ELF_ST_VISIBILITY (h->root.other)))))
3503 addend = rel->r_addend;
3507 case R_ALPHA_GPDISP:
3509 bfd_byte *p_ldah, *p_lda;
3511 BFD_ASSERT(gp != 0);
3513 relocation = (input_section->output_section->vma
3514 + input_section->output_offset
3517 p_ldah = contents + rel->r_offset - input_section->vma;
3518 p_lda = p_ldah + rel->r_addend;
3520 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3525 case R_ALPHA_OP_PUSH:
3526 case R_ALPHA_OP_STORE:
3527 case R_ALPHA_OP_PSUB:
3528 case R_ALPHA_OP_PRSHIFT:
3529 /* We hate these silly beasts. */
3532 case R_ALPHA_LITERAL:
3534 struct alpha_elf_got_entry *gotent;
3535 boolean dynamic_symbol;
3537 BFD_ASSERT(sgot != NULL);
3538 BFD_ASSERT(gp != 0);
3542 gotent = h->got_entries;
3543 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3547 gotent = (alpha_elf_tdata(input_bfd)->
3548 local_got_entries[r_symndx]);
3549 dynamic_symbol = false;
3552 BFD_ASSERT(gotent != NULL);
3554 while (gotent->gotobj != gotobj || gotent->addend != addend)
3555 gotent = gotent->next;
3557 BFD_ASSERT(gotent->use_count >= 1);
3559 /* Initialize the .got entry's value. */
3560 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3562 bfd_put_64 (output_bfd, relocation+addend,
3563 sgot->contents + gotent->got_offset);
3565 /* If the symbol has been forced local, output a
3566 RELATIVE reloc, otherwise it will be handled in
3567 finish_dynamic_symbol. */
3568 if (info->shared && !dynamic_symbol)
3570 Elf_Internal_Rela outrel;
3572 BFD_ASSERT(srelgot != NULL);
3574 outrel.r_offset = (sgot->output_section->vma
3575 + sgot->output_offset
3576 + gotent->got_offset);
3577 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3578 outrel.r_addend = 0;
3580 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3581 ((Elf64_External_Rela *)
3583 + srelgot->reloc_count++);
3584 BFD_ASSERT (sizeof(Elf64_External_Rela)
3585 * srelgot->reloc_count
3586 <= srelgot->_cooked_size);
3589 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3592 /* Figure the gprel relocation. */
3594 relocation = (sgot->output_section->vma
3595 + sgot->output_offset
3596 + gotent->got_offset);
3599 /* overflow handled by _bfd_final_link_relocate */
3602 case R_ALPHA_GPREL32:
3603 case R_ALPHA_GPRELLOW:
3604 BFD_ASSERT(gp != 0);
3608 case R_ALPHA_GPRELHIGH:
3609 BFD_ASSERT(gp != 0);
3611 relocation += addend;
3613 relocation = (((bfd_signed_vma) relocation >> 16)
3614 + ((relocation >> 15) & 1));
3617 case R_ALPHA_BRADDR:
3619 /* The regular PC-relative stuff measures from the start of
3620 the instruction rather than the end. */
3624 case R_ALPHA_REFLONG:
3625 case R_ALPHA_REFQUAD:
3627 Elf_Internal_Rela outrel;
3630 /* Careful here to remember RELATIVE relocations for global
3631 variables for symbolic shared objects. */
3633 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3635 BFD_ASSERT(h->root.dynindx != -1);
3636 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3637 outrel.r_addend = addend;
3638 addend = 0, relocation = 0;
3640 else if (info->shared && (input_section->flags & SEC_ALLOC))
3642 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3643 outrel.r_addend = 0;
3652 name = (bfd_elf_string_from_elf_section
3653 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3654 elf_section_data(input_section)->rel_hdr.sh_name));
3655 BFD_ASSERT(name != NULL);
3657 srel = bfd_get_section_by_name (dynobj, name);
3658 BFD_ASSERT(srel != NULL);
3663 if (elf_section_data (input_section)->stab_info == NULL)
3664 outrel.r_offset = rel->r_offset;
3669 off = (_bfd_stab_section_offset
3670 (output_bfd, &elf_hash_table (info)->stab_info,
3672 &elf_section_data (input_section)->stab_info,
3674 if (off == (bfd_vma) -1)
3676 outrel.r_offset = off;
3680 outrel.r_offset += (input_section->output_section->vma
3681 + input_section->output_offset);
3683 memset (&outrel, 0, sizeof outrel);
3685 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3686 ((Elf64_External_Rela *)
3688 + srel->reloc_count++);
3689 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3690 <= srel->_cooked_size);
3696 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3697 contents, rel->r_offset, relocation,
3707 case bfd_reloc_overflow:
3712 name = h->root.root.root.string;
3715 name = (bfd_elf_string_from_elf_section
3716 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3720 name = bfd_section_name (input_bfd, sec);
3722 if (! ((*info->callbacks->reloc_overflow)
3723 (info, name, howto->name, (bfd_vma) 0,
3724 input_bfd, input_section, rel->r_offset)))
3730 case bfd_reloc_outofrange:
3738 /* Finish up dynamic symbol handling. We set the contents of various
3739 dynamic sections here. */
3742 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3744 struct bfd_link_info *info;
3745 struct elf_link_hash_entry *h;
3746 Elf_Internal_Sym *sym;
3748 bfd *dynobj = elf_hash_table(info)->dynobj;
3750 if (h->plt.offset != MINUS_ONE)
3752 /* Fill in the .plt entry for this symbol. */
3753 asection *splt, *sgot, *srel;
3754 Elf_Internal_Rela outrel;
3755 bfd_vma got_addr, plt_addr;
3757 struct alpha_elf_got_entry *gotent;
3759 BFD_ASSERT (h->dynindx != -1);
3761 /* The first .got entry will be updated by the .plt with the
3762 address of the target function. */
3763 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3764 BFD_ASSERT (gotent && gotent->addend == 0);
3766 splt = bfd_get_section_by_name (dynobj, ".plt");
3767 BFD_ASSERT (splt != NULL);
3768 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3769 BFD_ASSERT (srel != NULL);
3770 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3771 BFD_ASSERT (sgot != NULL);
3773 got_addr = (sgot->output_section->vma
3774 + sgot->output_offset
3775 + gotent->got_offset);
3776 plt_addr = (splt->output_section->vma
3777 + splt->output_offset
3780 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3782 /* Fill in the entry in the procedure linkage table. */
3784 unsigned insn1, insn2, insn3;
3786 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3787 insn2 = PLT_ENTRY_WORD2;
3788 insn3 = PLT_ENTRY_WORD3;
3790 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3791 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3792 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3795 /* Fill in the entry in the .rela.plt section. */
3796 outrel.r_offset = got_addr;
3797 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3798 outrel.r_addend = 0;
3800 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3801 ((Elf64_External_Rela *)srel->contents
3804 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3806 /* Mark the symbol as undefined, rather than as defined in the
3807 .plt section. Leave the value alone. */
3808 sym->st_shndx = SHN_UNDEF;
3811 /* Fill in the entries in the .got. */
3812 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3814 /* Subsequent .got entries will continue to bounce through the .plt. */
3817 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3818 BFD_ASSERT (! info->shared || srel != NULL);
3820 gotent = gotent->next;
3823 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3824 BFD_ASSERT(sgot != NULL);
3825 BFD_ASSERT(gotent->addend == 0);
3827 bfd_put_64 (output_bfd, plt_addr,
3828 sgot->contents + gotent->got_offset);
3832 outrel.r_offset = (sgot->output_section->vma
3833 + sgot->output_offset
3834 + gotent->got_offset);
3835 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3836 outrel.r_addend = 0;
3838 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3839 ((Elf64_External_Rela *)
3841 + srel->reloc_count++);
3842 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3843 <= srel->_cooked_size);
3846 gotent = gotent->next;
3848 while (gotent != NULL);
3851 else if (alpha_elf_dynamic_symbol_p (h, info))
3853 /* Fill in the dynamic relocations for this symbol's .got entries. */
3855 Elf_Internal_Rela outrel;
3856 struct alpha_elf_got_entry *gotent;
3858 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3859 BFD_ASSERT (srel != NULL);
3861 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3862 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3864 gotent = gotent->next)
3866 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3867 outrel.r_offset = (sgot->output_section->vma
3868 + sgot->output_offset
3869 + gotent->got_offset);
3870 outrel.r_addend = gotent->addend;
3872 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3873 ((Elf64_External_Rela *)srel->contents
3874 + srel->reloc_count++));
3875 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3876 <= srel->_cooked_size);
3880 /* Mark some specially defined symbols as absolute. */
3881 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3882 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3883 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3884 sym->st_shndx = SHN_ABS;
3889 /* Finish up the dynamic sections. */
3892 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3894 struct bfd_link_info *info;
3899 dynobj = elf_hash_table (info)->dynobj;
3900 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3902 if (elf_hash_table (info)->dynamic_sections_created)
3905 Elf64_External_Dyn *dyncon, *dynconend;
3907 splt = bfd_get_section_by_name (dynobj, ".plt");
3908 BFD_ASSERT (splt != NULL && sdyn != NULL);
3910 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3911 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3912 for (; dyncon < dynconend; dyncon++)
3914 Elf_Internal_Dyn dyn;
3918 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3933 /* My interpretation of the TIS v1.1 ELF document indicates
3934 that RELASZ should not include JMPREL. This is not what
3935 the rest of the BFD does. It is, however, what the
3936 glibc ld.so wants. Do this fixup here until we found
3937 out who is right. */
3938 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3942 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3947 s = bfd_get_section_by_name (output_bfd, name);
3948 dyn.d_un.d_ptr = (s ? s->vma : 0);
3952 s = bfd_get_section_by_name (output_bfd, name);
3954 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3958 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3961 /* Initialize the PLT0 entry */
3962 if (splt->_raw_size > 0)
3964 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3965 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3966 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3967 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3969 /* The next two words will be filled in by ld.so */
3970 bfd_put_64 (output_bfd, 0, splt->contents + 16);
3971 bfd_put_64 (output_bfd, 0, splt->contents + 24);
3973 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3981 /* We need to use a special link routine to handle the .reginfo and
3982 the .mdebug sections. We need to merge all instances of these
3983 sections together, not write them all out sequentially. */
3986 elf64_alpha_final_link (abfd, info)
3988 struct bfd_link_info *info;
3991 struct bfd_link_order *p;
3992 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
3993 struct ecoff_debug_info debug;
3994 const struct ecoff_debug_swap *swap
3995 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3996 HDRR *symhdr = &debug.symbolic_header;
3997 PTR mdebug_handle = NULL;
4002 (*info->callbacks->warning)
4003 (info, _("using multiple gp values"), (char *) NULL,
4004 output_bfd, (asection *) NULL, (bfd_vma) 0);
4008 /* Go through the sections and collect the .reginfo and .mdebug
4012 gptab_data_sec = NULL;
4013 gptab_bss_sec = NULL;
4014 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4016 #ifdef ERIC_neverdef
4017 if (strcmp (o->name, ".reginfo") == 0)
4019 memset (®info, 0, sizeof reginfo);
4021 /* We have found the .reginfo section in the output file.
4022 Look through all the link_orders comprising it and merge
4023 the information together. */
4024 for (p = o->link_order_head;
4025 p != (struct bfd_link_order *) NULL;
4028 asection *input_section;
4030 Elf64_External_RegInfo ext;
4033 if (p->type != bfd_indirect_link_order)
4035 if (p->type == bfd_fill_link_order)
4040 input_section = p->u.indirect.section;
4041 input_bfd = input_section->owner;
4043 /* The linker emulation code has probably clobbered the
4044 size to be zero bytes. */
4045 if (input_section->_raw_size == 0)
4046 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4048 if (! bfd_get_section_contents (input_bfd, input_section,
4054 bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4056 reginfo.ri_gprmask |= sub.ri_gprmask;
4057 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4058 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4059 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4060 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4062 /* ri_gp_value is set by the function
4063 alpha_elf_section_processing when the section is
4064 finally written out. */
4066 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4067 elf_link_input_bfd ignores this section. */
4068 input_section->flags &=~ SEC_HAS_CONTENTS;
4071 /* Force the section size to the value we want. */
4072 o->_raw_size = sizeof (Elf64_External_RegInfo);
4074 /* Skip this section later on (I don't think this currently
4075 matters, but someday it might). */
4076 o->link_order_head = (struct bfd_link_order *) NULL;
4082 if (strcmp (o->name, ".mdebug") == 0)
4084 struct extsym_info einfo;
4086 /* We have found the .mdebug section in the output file.
4087 Look through all the link_orders comprising it and merge
4088 the information together. */
4089 symhdr->magic = swap->sym_magic;
4090 /* FIXME: What should the version stamp be? */
4092 symhdr->ilineMax = 0;
4096 symhdr->isymMax = 0;
4097 symhdr->ioptMax = 0;
4098 symhdr->iauxMax = 0;
4100 symhdr->issExtMax = 0;
4103 symhdr->iextMax = 0;
4105 /* We accumulate the debugging information itself in the
4106 debug_info structure. */
4108 debug.external_dnr = NULL;
4109 debug.external_pdr = NULL;
4110 debug.external_sym = NULL;
4111 debug.external_opt = NULL;
4112 debug.external_aux = NULL;
4114 debug.ssext = debug.ssext_end = NULL;
4115 debug.external_fdr = NULL;
4116 debug.external_rfd = NULL;
4117 debug.external_ext = debug.external_ext_end = NULL;
4119 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4120 if (mdebug_handle == (PTR) NULL)
4129 static const char * const name[] =
4131 ".text", ".init", ".fini", ".data",
4132 ".rodata", ".sdata", ".sbss", ".bss"
4134 static const int sc[] = { scText, scInit, scFini, scData,
4135 scRData, scSData, scSBss, scBss };
4138 esym.cobol_main = 0;
4142 esym.asym.iss = issNil;
4143 esym.asym.st = stLocal;
4144 esym.asym.reserved = 0;
4145 esym.asym.index = indexNil;
4146 for (i = 0; i < 8; i++)
4148 esym.asym.sc = sc[i];
4149 s = bfd_get_section_by_name (abfd, name[i]);
4152 esym.asym.value = s->vma;
4153 last = s->vma + s->_raw_size;
4156 esym.asym.value = last;
4158 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4164 for (p = o->link_order_head;
4165 p != (struct bfd_link_order *) NULL;
4168 asection *input_section;
4170 const struct ecoff_debug_swap *input_swap;
4171 struct ecoff_debug_info input_debug;
4175 if (p->type != bfd_indirect_link_order)
4177 if (p->type == bfd_fill_link_order)
4182 input_section = p->u.indirect.section;
4183 input_bfd = input_section->owner;
4185 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4186 || (get_elf_backend_data (input_bfd)
4187 ->elf_backend_ecoff_debug_swap) == NULL)
4189 /* I don't know what a non ALPHA ELF bfd would be
4190 doing with a .mdebug section, but I don't really
4191 want to deal with it. */
4195 input_swap = (get_elf_backend_data (input_bfd)
4196 ->elf_backend_ecoff_debug_swap);
4198 BFD_ASSERT (p->size == input_section->_raw_size);
4200 /* The ECOFF linking code expects that we have already
4201 read in the debugging information and set up an
4202 ecoff_debug_info structure, so we do that now. */
4203 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4207 if (! (bfd_ecoff_debug_accumulate
4208 (mdebug_handle, abfd, &debug, swap, input_bfd,
4209 &input_debug, input_swap, info)))
4212 /* Loop through the external symbols. For each one with
4213 interesting information, try to find the symbol in
4214 the linker global hash table and save the information
4215 for the output external symbols. */
4216 eraw_src = input_debug.external_ext;
4217 eraw_end = (eraw_src
4218 + (input_debug.symbolic_header.iextMax
4219 * input_swap->external_ext_size));
4221 eraw_src < eraw_end;
4222 eraw_src += input_swap->external_ext_size)
4226 struct alpha_elf_link_hash_entry *h;
4228 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4229 if (ext.asym.sc == scNil
4230 || ext.asym.sc == scUndefined
4231 || ext.asym.sc == scSUndefined)
4234 name = input_debug.ssext + ext.asym.iss;
4235 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4236 name, false, false, true);
4237 if (h == NULL || h->esym.ifd != -2)
4243 < input_debug.symbolic_header.ifdMax);
4244 ext.ifd = input_debug.ifdmap[ext.ifd];
4250 /* Free up the information we just read. */
4251 free (input_debug.line);
4252 free (input_debug.external_dnr);
4253 free (input_debug.external_pdr);
4254 free (input_debug.external_sym);
4255 free (input_debug.external_opt);
4256 free (input_debug.external_aux);
4257 free (input_debug.ss);
4258 free (input_debug.ssext);
4259 free (input_debug.external_fdr);
4260 free (input_debug.external_rfd);
4261 free (input_debug.external_ext);
4263 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4264 elf_link_input_bfd ignores this section. */
4265 input_section->flags &=~ SEC_HAS_CONTENTS;
4268 #ifdef ERIC_neverdef
4271 /* Create .rtproc section. */
4272 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4273 if (rtproc_sec == NULL)
4275 flagword flags = (SEC_HAS_CONTENTS
4277 | SEC_LINKER_CREATED
4280 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4281 if (rtproc_sec == NULL
4282 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4283 || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4287 if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4288 info, rtproc_sec, &debug))
4294 /* Build the external symbol information. */
4297 einfo.debug = &debug;
4299 einfo.failed = false;
4300 elf_link_hash_traverse (elf_hash_table (info),
4301 elf64_alpha_output_extsym,
4306 /* Set the size of the .mdebug section. */
4307 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4309 /* Skip this section later on (I don't think this currently
4310 matters, but someday it might). */
4311 o->link_order_head = (struct bfd_link_order *) NULL;
4316 #ifdef ERIC_neverdef
4317 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4319 const char *subname;
4322 Elf64_External_gptab *ext_tab;
4325 /* The .gptab.sdata and .gptab.sbss sections hold
4326 information describing how the small data area would
4327 change depending upon the -G switch. These sections
4328 not used in executables files. */
4329 if (! info->relocateable)
4333 for (p = o->link_order_head;
4334 p != (struct bfd_link_order *) NULL;
4337 asection *input_section;
4339 if (p->type != bfd_indirect_link_order)
4341 if (p->type == bfd_fill_link_order)
4346 input_section = p->u.indirect.section;
4348 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4349 elf_link_input_bfd ignores this section. */
4350 input_section->flags &=~ SEC_HAS_CONTENTS;
4353 /* Skip this section later on (I don't think this
4354 currently matters, but someday it might). */
4355 o->link_order_head = (struct bfd_link_order *) NULL;
4357 /* Really remove the section. */
4358 for (secpp = &abfd->sections;
4360 secpp = &(*secpp)->next)
4362 *secpp = (*secpp)->next;
4363 --abfd->section_count;
4368 /* There is one gptab for initialized data, and one for
4369 uninitialized data. */
4370 if (strcmp (o->name, ".gptab.sdata") == 0)
4372 else if (strcmp (o->name, ".gptab.sbss") == 0)
4376 (*_bfd_error_handler)
4377 (_("%s: illegal section name `%s'"),
4378 bfd_get_filename (abfd), o->name);
4379 bfd_set_error (bfd_error_nonrepresentable_section);
4383 /* The linker script always combines .gptab.data and
4384 .gptab.sdata into .gptab.sdata, and likewise for
4385 .gptab.bss and .gptab.sbss. It is possible that there is
4386 no .sdata or .sbss section in the output file, in which
4387 case we must change the name of the output section. */
4388 subname = o->name + sizeof ".gptab" - 1;
4389 if (bfd_get_section_by_name (abfd, subname) == NULL)
4391 if (o == gptab_data_sec)
4392 o->name = ".gptab.data";
4394 o->name = ".gptab.bss";
4395 subname = o->name + sizeof ".gptab" - 1;
4396 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4399 /* Set up the first entry. */
4401 tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4404 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4405 tab[0].gt_header.gt_unused = 0;
4407 /* Combine the input sections. */
4408 for (p = o->link_order_head;
4409 p != (struct bfd_link_order *) NULL;
4412 asection *input_section;
4416 bfd_size_type gpentry;
4418 if (p->type != bfd_indirect_link_order)
4420 if (p->type == bfd_fill_link_order)
4425 input_section = p->u.indirect.section;
4426 input_bfd = input_section->owner;
4428 /* Combine the gptab entries for this input section one
4429 by one. We know that the input gptab entries are
4430 sorted by ascending -G value. */
4431 size = bfd_section_size (input_bfd, input_section);
4433 for (gpentry = sizeof (Elf64_External_gptab);
4435 gpentry += sizeof (Elf64_External_gptab))
4437 Elf64_External_gptab ext_gptab;
4438 Elf64_gptab int_gptab;
4444 if (! (bfd_get_section_contents
4445 (input_bfd, input_section, (PTR) &ext_gptab,
4446 gpentry, sizeof (Elf64_External_gptab))))
4452 bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4454 val = int_gptab.gt_entry.gt_g_value;
4455 add = int_gptab.gt_entry.gt_bytes - last;
4458 for (look = 1; look < c; look++)
4460 if (tab[look].gt_entry.gt_g_value >= val)
4461 tab[look].gt_entry.gt_bytes += add;
4463 if (tab[look].gt_entry.gt_g_value == val)
4469 Elf64_gptab *new_tab;
4472 /* We need a new table entry. */
4473 new_tab = ((Elf64_gptab *)
4474 bfd_realloc ((PTR) tab,
4475 (c + 1) * sizeof (Elf64_gptab)));
4476 if (new_tab == NULL)
4482 tab[c].gt_entry.gt_g_value = val;
4483 tab[c].gt_entry.gt_bytes = add;
4485 /* Merge in the size for the next smallest -G
4486 value, since that will be implied by this new
4489 for (look = 1; look < c; look++)
4491 if (tab[look].gt_entry.gt_g_value < val
4493 || (tab[look].gt_entry.gt_g_value
4494 > tab[max].gt_entry.gt_g_value)))
4498 tab[c].gt_entry.gt_bytes +=
4499 tab[max].gt_entry.gt_bytes;
4504 last = int_gptab.gt_entry.gt_bytes;
4507 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4508 elf_link_input_bfd ignores this section. */
4509 input_section->flags &=~ SEC_HAS_CONTENTS;
4512 /* The table must be sorted by -G value. */
4514 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4516 /* Swap out the table. */
4517 ext_tab = ((Elf64_External_gptab *)
4518 bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4519 if (ext_tab == NULL)
4525 for (i = 0; i < c; i++)
4526 bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4529 o->_raw_size = c * sizeof (Elf64_External_gptab);
4530 o->contents = (bfd_byte *) ext_tab;
4532 /* Skip this section later on (I don't think this currently
4533 matters, but someday it might). */
4534 o->link_order_head = (struct bfd_link_order *) NULL;
4540 /* Invoke the regular ELF backend linker to do all the work. */
4541 if (! bfd_elf64_bfd_final_link (abfd, info))
4544 /* Now write out the computed sections. */
4546 /* The .got subsections... */
4548 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4549 for (i = alpha_elf_hash_table(info)->got_list;
4551 i = alpha_elf_tdata(i)->got_link_next)
4555 /* elf_bfd_final_link already did everything in dynobj. */
4559 sgot = alpha_elf_tdata(i)->got;
4560 if (! bfd_set_section_contents (abfd, sgot->output_section,
4561 sgot->contents, sgot->output_offset,
4567 #ifdef ERIC_neverdef
4568 if (reginfo_sec != (asection *) NULL)
4570 Elf64_External_RegInfo ext;
4572 bfd_alpha_elf64_swap_reginfo_out (abfd, ®info, &ext);
4573 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4574 (file_ptr) 0, sizeof ext))
4579 if (mdebug_sec != (asection *) NULL)
4581 BFD_ASSERT (abfd->output_has_begun);
4582 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4584 mdebug_sec->filepos))
4587 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4590 if (gptab_data_sec != (asection *) NULL)
4592 if (! bfd_set_section_contents (abfd, gptab_data_sec,
4593 gptab_data_sec->contents,
4595 gptab_data_sec->_raw_size))
4599 if (gptab_bss_sec != (asection *) NULL)
4601 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4602 gptab_bss_sec->contents,
4604 gptab_bss_sec->_raw_size))
4611 /* ECOFF swapping routines. These are used when dealing with the
4612 .mdebug section, which is in the ECOFF debugging format. Copied
4613 from elf32-mips.c. */
4614 static const struct ecoff_debug_swap
4615 elf64_alpha_ecoff_debug_swap =
4617 /* Symbol table magic number. */
4619 /* Alignment of debugging information. E.g., 4. */
4621 /* Sizes of external symbolic information. */
4622 sizeof (struct hdr_ext),
4623 sizeof (struct dnr_ext),
4624 sizeof (struct pdr_ext),
4625 sizeof (struct sym_ext),
4626 sizeof (struct opt_ext),
4627 sizeof (struct fdr_ext),
4628 sizeof (struct rfd_ext),
4629 sizeof (struct ext_ext),
4630 /* Functions to swap in external symbolic data. */
4639 _bfd_ecoff_swap_tir_in,
4640 _bfd_ecoff_swap_rndx_in,
4641 /* Functions to swap out external symbolic data. */
4650 _bfd_ecoff_swap_tir_out,
4651 _bfd_ecoff_swap_rndx_out,
4652 /* Function to read in symbolic data. */
4653 elf64_alpha_read_ecoff_info
4656 /* Use a non-standard hash bucket size of 8. */
4658 const struct elf_size_info alpha_elf_size_info =
4660 sizeof (Elf64_External_Ehdr),
4661 sizeof (Elf64_External_Phdr),
4662 sizeof (Elf64_External_Shdr),
4663 sizeof (Elf64_External_Rel),
4664 sizeof (Elf64_External_Rela),
4665 sizeof (Elf64_External_Sym),
4666 sizeof (Elf64_External_Dyn),
4667 sizeof (Elf_External_Note),
4671 ELFCLASS64, EV_CURRENT,
4672 bfd_elf64_write_out_phdrs,
4673 bfd_elf64_write_shdrs_and_ehdr,
4674 bfd_elf64_write_relocs,
4675 bfd_elf64_swap_symbol_out,
4676 bfd_elf64_slurp_reloc_table,
4677 bfd_elf64_slurp_symbol_table,
4678 bfd_elf64_swap_dyn_in,
4679 bfd_elf64_swap_dyn_out,
4686 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4687 #define TARGET_LITTLE_NAME "elf64-alpha"
4688 #define ELF_ARCH bfd_arch_alpha
4689 #define ELF_MACHINE_CODE EM_ALPHA
4690 #define ELF_MAXPAGESIZE 0x10000
4692 #define bfd_elf64_bfd_link_hash_table_create \
4693 elf64_alpha_bfd_link_hash_table_create
4695 #define bfd_elf64_bfd_reloc_type_lookup \
4696 elf64_alpha_bfd_reloc_type_lookup
4697 #define elf_info_to_howto \
4698 elf64_alpha_info_to_howto
4700 #define bfd_elf64_mkobject \
4701 elf64_alpha_mkobject
4702 #define elf_backend_object_p \
4703 elf64_alpha_object_p
4705 #define elf_backend_section_from_shdr \
4706 elf64_alpha_section_from_shdr
4707 #define elf_backend_fake_sections \
4708 elf64_alpha_fake_sections
4710 #define bfd_elf64_bfd_is_local_label_name \
4711 elf64_alpha_is_local_label_name
4712 #define bfd_elf64_find_nearest_line \
4713 elf64_alpha_find_nearest_line
4714 #define bfd_elf64_bfd_relax_section \
4715 elf64_alpha_relax_section
4717 #define elf_backend_add_symbol_hook \
4718 elf64_alpha_add_symbol_hook
4719 #define elf_backend_check_relocs \
4720 elf64_alpha_check_relocs
4721 #define elf_backend_create_dynamic_sections \
4722 elf64_alpha_create_dynamic_sections
4723 #define elf_backend_adjust_dynamic_symbol \
4724 elf64_alpha_adjust_dynamic_symbol
4725 #define elf_backend_always_size_sections \
4726 elf64_alpha_always_size_sections
4727 #define elf_backend_size_dynamic_sections \
4728 elf64_alpha_size_dynamic_sections
4729 #define elf_backend_relocate_section \
4730 elf64_alpha_relocate_section
4731 #define elf_backend_finish_dynamic_symbol \
4732 elf64_alpha_finish_dynamic_symbol
4733 #define elf_backend_finish_dynamic_sections \
4734 elf64_alpha_finish_dynamic_sections
4735 #define bfd_elf64_bfd_final_link \
4736 elf64_alpha_final_link
4738 #define elf_backend_ecoff_debug_swap \
4739 &elf64_alpha_ecoff_debug_swap
4741 #define elf_backend_size_info \
4745 * A few constants that determine how the .plt section is set up.
4747 #define elf_backend_want_got_plt 0
4748 #define elf_backend_plt_readonly 0
4749 #define elf_backend_want_plt_sym 1
4750 #define elf_backend_got_header_size 0
4751 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4753 #include "elf64-target.h"