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;
1130 fits16 = (disp >= -(bfd_signed_vma)0x8000 && disp < 0x8000);
1131 fits32 = (disp >= -(bfd_signed_vma)0x80000000 && disp < 0x7fff8000);
1133 for (urel = irel+1, i = 0; i < count; ++i, ++urel)
1136 insn = bfd_get_32 (info->abfd, info->contents + urel->r_offset);
1138 switch (urel->r_addend)
1140 default: /* 0 = ADDRESS FORMAT */
1141 /* This type is really just a placeholder to note that all
1142 uses cannot be optimized, but to still allow some. */
1143 all_optimized = false;
1146 case 1: /* MEM FORMAT */
1147 /* We can always optimize 16-bit displacements. */
1150 /* FIXME: sanity check the insn for mem format with
1153 /* Take the op code and dest from this insn, take the base
1154 register from the literal insn. Leave the offset alone. */
1155 insn = (insn & 0xffe00000) | (lit_insn & 0x001f0000);
1156 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1158 urel->r_addend = irel->r_addend;
1159 info->changed_relocs = true;
1161 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1162 info->changed_contents = true;
1165 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1166 else if (fits32 && !(flags & ~6))
1168 /* FIXME: sanity check that lit insn Ra is mem insn Rb, and
1169 that mem_insn disp is zero. */
1171 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1173 lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
1174 bfd_put_32 (info->abfd, lit_insn,
1175 info->contents + irel->r_offset);
1177 info->changed_contents = true;
1179 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1181 urel->r_addend = irel->r_addend;
1182 info->changed_relocs = true;
1185 all_optimized = false;
1188 case 2: /* BYTE OFFSET FORMAT */
1189 /* We can always optimize byte instructions. */
1191 /* FIXME: sanity check the insn for byte op. Check that the
1192 literal dest reg is indeed Rb in the byte insn. */
1194 insn = (insn & ~0x001ff000) | ((symval & 7) << 13) | 0x1000;
1196 urel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1198 info->changed_relocs = true;
1200 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1201 info->changed_contents = true;
1204 case 3: /* CALL FORMAT */
1206 /* If not zero, place to jump without needing pv. */
1207 bfd_vma optdest = elf64_alpha_relax_opt_call (info, symval);
1208 bfd_vma org = (info->sec->output_section->vma
1209 + info->sec->output_offset
1210 + urel->r_offset + 4);
1211 bfd_signed_vma odisp;
1213 odisp = (optdest ? optdest : symval) - org;
1214 if (odisp >= -0x400000 && odisp < 0x400000)
1216 Elf_Internal_Rela *xrel;
1218 /* Preserve branch prediction call stack when possible. */
1219 if ((insn & INSN_JSR_MASK) == INSN_JSR)
1220 insn = (OP_BSR << 26) | (insn & 0x03e00000);
1222 insn = (OP_BR << 26) | (insn & 0x03e00000);
1224 urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
1226 urel->r_addend = irel->r_addend;
1229 urel->r_addend += optdest - symval;
1231 all_optimized = false;
1233 bfd_put_32 (info->abfd, insn, info->contents + urel->r_offset);
1235 /* Kill any HINT reloc that might exist for this insn. */
1236 xrel = (elf64_alpha_find_reloc_at_ofs
1237 (info->relocs, info->relend, urel->r_offset,
1240 xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1242 info->changed_contents = true;
1243 info->changed_relocs = true;
1246 all_optimized = false;
1248 /* ??? If target gp == current gp we can eliminate the gp reload.
1249 This does depend on every place a gp could be reloaded will
1250 be, which currently happens for all code produced by gcc, but
1251 not necessarily by hand-coded assembly, or if sibling calls
1254 Perhaps conditionalize this on a flag being set in the target
1255 object file's header, and have gcc set it? */
1261 /* If all cases were optimized, we can reduce the use count on this
1262 got entry by one, possibly eliminating it. */
1265 info->gotent->use_count -= 1;
1266 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1268 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1270 /* If the literal instruction is no longer needed (it may have been
1271 reused. We can eliminate it.
1272 ??? For now, I don't want to deal with compacting the section,
1273 so just nop it out. */
1276 irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
1277 info->changed_relocs = true;
1279 bfd_put_32 (info->abfd, INSN_UNOP, info->contents + irel->r_offset);
1280 info->changed_contents = true;
1284 return irel + count;
1288 elf64_alpha_relax_opt_call (info, symval)
1289 struct alpha_relax_info *info;
1292 /* If the function has the same gp, and we can identify that the
1293 function does not use its function pointer, we can eliminate the
1296 /* If the symbol is marked NOPV, we are being told the function never
1297 needs its procedure value. */
1298 if (info->other == STO_ALPHA_NOPV)
1301 /* If the symbol is marked STD_GP, we are being told the function does
1302 a normal ldgp in the first two words. */
1303 else if (info->other == STO_ALPHA_STD_GPLOAD)
1306 /* Otherwise, we may be able to identify a GP load in the first two
1307 words, which we can then skip. */
1310 Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
1313 /* Load the relocations from the section that the target symbol is in. */
1314 if (info->sec == info->tsec)
1316 tsec_relocs = info->relocs;
1317 tsec_relend = info->relend;
1322 tsec_relocs = (_bfd_elf64_link_read_relocs
1323 (info->abfd, info->tsec, (PTR) NULL,
1324 (Elf_Internal_Rela *) NULL,
1325 info->link_info->keep_memory));
1326 if (tsec_relocs == NULL)
1328 tsec_relend = tsec_relocs + info->tsec->reloc_count;
1329 tsec_free = (info->link_info->keep_memory ? NULL : tsec_relocs);
1332 /* Recover the symbol's offset within the section. */
1333 ofs = (symval - info->tsec->output_section->vma
1334 - info->tsec->output_offset);
1336 /* Look for a GPDISP reloc. */
1337 gpdisp = (elf64_alpha_find_reloc_at_ofs
1338 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
1340 if (!gpdisp || gpdisp->r_addend != 4)
1350 /* We've now determined that we can skip an initial gp load. Verify
1351 that the call and the target use the same gp. */
1352 if (info->link_info->hash->creator != info->tsec->owner->xvec
1353 || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
1360 elf64_alpha_relax_without_lituse (info, symval, irel)
1361 struct alpha_relax_info *info;
1363 Elf_Internal_Rela *irel;
1366 bfd_signed_vma disp;
1368 /* Get the instruction. */
1369 insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
1371 if (insn >> 26 != OP_LDQ)
1373 ((*_bfd_error_handler)
1374 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1375 bfd_get_filename (info->abfd), info->sec->name,
1376 (unsigned long) irel->r_offset));
1380 /* So we aren't told much. Do what we can with the address load and
1381 fake the rest. All of the optimizations here require that the
1382 offset from the GP fit in 16 bits. */
1384 disp = symval - info->gp;
1385 if (disp < -0x8000 || disp >= 0x8000)
1388 /* On the LITERAL instruction itself, consider exchanging
1389 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1391 insn = (OP_LDA << 26) | (insn & 0x03ff0000);
1392 bfd_put_32 (info->abfd, insn, info->contents + irel->r_offset);
1393 info->changed_contents = true;
1395 irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), R_ALPHA_GPRELLOW);
1396 info->changed_relocs = true;
1398 /* Reduce the use count on this got entry by one, possibly
1400 info->gotent->use_count -= 1;
1401 alpha_elf_tdata (info->gotent->gotobj)->total_got_entries -= 1;
1403 alpha_elf_tdata (info->gotent->gotobj)->n_local_got_entries -= 1;
1405 /* ??? Search forward through this basic block looking for insns
1406 that use the target register. Stop after an insn modifying the
1407 register is seen, or after a branch or call.
1409 Any such memory load insn may be substituted by a load directly
1410 off the GP. This allows the memory load insn to be issued before
1411 the calculated GP register would otherwise be ready.
1413 Any such jsr insn can be replaced by a bsr if it is in range.
1415 This would mean that we'd have to _add_ relocations, the pain of
1416 which gives one pause. */
1422 elf64_alpha_relax_section (abfd, sec, link_info, again)
1425 struct bfd_link_info *link_info;
1428 Elf_Internal_Shdr *symtab_hdr;
1429 Elf_Internal_Rela *internal_relocs;
1430 Elf_Internal_Rela *free_relocs = NULL;
1431 Elf_Internal_Rela *irel, *irelend;
1432 bfd_byte *free_contents = NULL;
1433 Elf64_External_Sym *extsyms = NULL;
1434 Elf64_External_Sym *free_extsyms = NULL;
1435 struct alpha_elf_got_entry **local_got_entries;
1436 struct alpha_relax_info info;
1438 /* We are not currently changing any sizes, so only one pass. */
1441 if (link_info->relocateable
1442 || (sec->flags & SEC_RELOC) == 0
1443 || sec->reloc_count == 0)
1446 /* If this is the first time we have been called for this section,
1447 initialize the cooked size. */
1448 if (sec->_cooked_size == 0)
1449 sec->_cooked_size = sec->_raw_size;
1451 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1452 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1454 /* Load the relocations for this section. */
1455 internal_relocs = (_bfd_elf64_link_read_relocs
1456 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1457 link_info->keep_memory));
1458 if (internal_relocs == NULL)
1460 if (! link_info->keep_memory)
1461 free_relocs = internal_relocs;
1463 memset(&info, 0, sizeof(info));
1466 info.link_info = link_info;
1467 info.relocs = internal_relocs;
1468 info.relend = irelend = internal_relocs + sec->reloc_count;
1470 /* Find the GP for this object. */
1471 info.gotobj = alpha_elf_tdata (abfd)->gotobj;
1474 asection *sgot = alpha_elf_tdata (info.gotobj)->got;
1475 info.gp = _bfd_get_gp_value (info.gotobj);
1478 info.gp = (sgot->output_section->vma
1479 + sgot->output_offset
1481 _bfd_set_gp_value (info.gotobj, info.gp);
1485 for (irel = internal_relocs; irel < irelend; irel++)
1488 Elf_Internal_Sym isym;
1489 struct alpha_elf_got_entry *gotent;
1491 if (ELF64_R_TYPE (irel->r_info) != (int) R_ALPHA_LITERAL)
1494 /* Get the section contents. */
1495 if (info.contents == NULL)
1497 if (elf_section_data (sec)->this_hdr.contents != NULL)
1498 info.contents = elf_section_data (sec)->this_hdr.contents;
1501 info.contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1502 if (info.contents == NULL)
1504 free_contents = info.contents;
1506 if (! bfd_get_section_contents (abfd, sec, info.contents,
1507 (file_ptr) 0, sec->_raw_size))
1512 /* Read this BFD's symbols if we haven't done so already. */
1513 if (extsyms == NULL)
1515 if (symtab_hdr->contents != NULL)
1516 extsyms = (Elf64_External_Sym *) symtab_hdr->contents;
1519 extsyms = ((Elf64_External_Sym *)
1520 bfd_malloc (symtab_hdr->sh_size));
1521 if (extsyms == NULL)
1523 free_extsyms = extsyms;
1524 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1525 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1526 != symtab_hdr->sh_size))
1531 /* Get the value of the symbol referred to by the reloc. */
1532 if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1534 /* A local symbol. */
1535 bfd_elf64_swap_symbol_in (abfd,
1536 extsyms + ELF64_R_SYM (irel->r_info),
1538 if (isym.st_shndx == SHN_UNDEF)
1539 info.tsec = bfd_und_section_ptr;
1540 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1541 info.tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1542 else if (isym.st_shndx == SHN_ABS)
1543 info.tsec = bfd_abs_section_ptr;
1544 else if (isym.st_shndx == SHN_COMMON)
1545 info.tsec = bfd_com_section_ptr;
1547 continue; /* who knows. */
1550 info.other = isym.st_other;
1551 gotent = local_got_entries[ELF64_R_SYM(irel->r_info)];
1552 symval = isym.st_value;
1557 struct alpha_elf_link_hash_entry *h;
1559 indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1560 h = alpha_elf_sym_hashes (abfd)[indx];
1561 BFD_ASSERT (h != NULL);
1563 while (h->root.root.type == bfd_link_hash_indirect
1564 || h->root.root.type == bfd_link_hash_warning)
1565 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1567 /* We can't do anthing with undefined or dynamic symbols. */
1568 if (h->root.root.type == bfd_link_hash_undefined
1569 || h->root.root.type == bfd_link_hash_undefweak
1570 || alpha_elf_dynamic_symbol_p (&h->root, link_info))
1574 info.gotent = gotent;
1575 info.tsec = h->root.root.u.def.section;
1576 info.other = h->root.other;
1577 gotent = h->got_entries;
1578 symval = h->root.root.u.def.value;
1581 /* Search for the got entry to be used by this relocation. */
1582 while (gotent->gotobj != info.gotobj || gotent->addend != irel->r_addend)
1583 gotent = gotent->next;
1584 info.gotent = gotent;
1586 symval += info.tsec->output_section->vma + info.tsec->output_offset;
1587 symval += irel->r_addend;
1589 BFD_ASSERT(info.gotent != NULL);
1591 /* If there exist LITUSE relocations immediately following, this
1592 opens up all sorts of interesting optimizations, because we
1593 now know every location that this address load is used. */
1595 if (irel+1 < irelend && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
1597 irel = elf64_alpha_relax_with_lituse (&info, symval, irel, irelend);
1603 if (!elf64_alpha_relax_without_lituse (&info, symval, irel))
1608 if (!elf64_alpha_size_got_sections (abfd, link_info))
1611 if (info.changed_relocs)
1613 elf_section_data (sec)->relocs = internal_relocs;
1615 else if (free_relocs != NULL)
1620 if (info.changed_contents)
1622 elf_section_data (sec)->this_hdr.contents = info.contents;
1624 else if (free_contents != NULL)
1626 if (! link_info->keep_memory)
1627 free (free_contents);
1630 /* Cache the section contents for elf_link_input_bfd. */
1631 elf_section_data (sec)->this_hdr.contents = info.contents;
1635 if (free_extsyms != NULL)
1637 if (! link_info->keep_memory)
1638 free (free_extsyms);
1641 /* Cache the symbols for elf_link_input_bfd. */
1642 symtab_hdr->contents = extsyms;
1646 *again = info.changed_contents || info.changed_relocs;
1651 if (free_relocs != NULL)
1653 if (free_contents != NULL)
1654 free (free_contents);
1655 if (free_extsyms != NULL)
1656 free (free_extsyms);
1661 #define PLT_HEADER_SIZE 32
1662 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1663 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1664 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1665 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1667 #define PLT_ENTRY_SIZE 12
1668 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1669 #define PLT_ENTRY_WORD2 0
1670 #define PLT_ENTRY_WORD3 0
1672 #define MAX_GOT_ENTRIES (64*1024 / 8)
1674 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1676 /* Handle an Alpha specific section when reading an object file. This
1677 is called when elfcode.h finds a section with an unknown type.
1678 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1682 elf64_alpha_section_from_shdr (abfd, hdr, name)
1684 Elf64_Internal_Shdr *hdr;
1689 /* There ought to be a place to keep ELF backend specific flags, but
1690 at the moment there isn't one. We just keep track of the
1691 sections by their name, instead. Fortunately, the ABI gives
1692 suggested names for all the MIPS specific sections, so we will
1693 probably get away with this. */
1694 switch (hdr->sh_type)
1696 case SHT_ALPHA_DEBUG:
1697 if (strcmp (name, ".mdebug") != 0)
1700 #ifdef ERIC_neverdef
1701 case SHT_ALPHA_REGINFO:
1702 if (strcmp (name, ".reginfo") != 0
1703 || hdr->sh_size != sizeof (Elf64_External_RegInfo))
1711 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1713 newsect = hdr->bfd_section;
1715 if (hdr->sh_type == SHT_ALPHA_DEBUG)
1717 if (! bfd_set_section_flags (abfd, newsect,
1718 (bfd_get_section_flags (abfd, newsect)
1723 #ifdef ERIC_neverdef
1724 /* For a .reginfo section, set the gp value in the tdata information
1725 from the contents of this section. We need the gp value while
1726 processing relocs, so we just get it now. */
1727 if (hdr->sh_type == SHT_ALPHA_REGINFO)
1729 Elf64_External_RegInfo ext;
1732 if (! bfd_get_section_contents (abfd, newsect, (PTR) &ext,
1733 (file_ptr) 0, sizeof ext))
1735 bfd_alpha_elf64_swap_reginfo_in (abfd, &ext, &s);
1736 elf_gp (abfd) = s.ri_gp_value;
1743 /* Set the correct type for an Alpha ELF section. We do this by the
1744 section name, which is a hack, but ought to work. */
1747 elf64_alpha_fake_sections (abfd, hdr, sec)
1749 Elf64_Internal_Shdr *hdr;
1752 register const char *name;
1754 name = bfd_get_section_name (abfd, sec);
1756 if (strcmp (name, ".mdebug") == 0)
1758 hdr->sh_type = SHT_ALPHA_DEBUG;
1759 /* In a shared object on Irix 5.3, the .mdebug section has an
1760 entsize of 0. FIXME: Does this matter? */
1761 if ((abfd->flags & DYNAMIC) != 0 )
1762 hdr->sh_entsize = 0;
1764 hdr->sh_entsize = 1;
1766 #ifdef ERIC_neverdef
1767 else if (strcmp (name, ".reginfo") == 0)
1769 hdr->sh_type = SHT_ALPHA_REGINFO;
1770 /* In a shared object on Irix 5.3, the .reginfo section has an
1771 entsize of 0x18. FIXME: Does this matter? */
1772 if ((abfd->flags & DYNAMIC) != 0)
1773 hdr->sh_entsize = sizeof (Elf64_External_RegInfo);
1775 hdr->sh_entsize = 1;
1777 /* Force the section size to the correct value, even if the
1778 linker thinks it is larger. The link routine below will only
1779 write out this much data for .reginfo. */
1780 hdr->sh_size = sec->_raw_size = sizeof (Elf64_External_RegInfo);
1782 else if (strcmp (name, ".hash") == 0
1783 || strcmp (name, ".dynamic") == 0
1784 || strcmp (name, ".dynstr") == 0)
1786 hdr->sh_entsize = 0;
1787 hdr->sh_info = SIZEOF_ALPHA_DYNSYM_SECNAMES;
1790 else if (strcmp (name, ".sdata") == 0
1791 || strcmp (name, ".sbss") == 0
1792 || strcmp (name, ".lit4") == 0
1793 || strcmp (name, ".lit8") == 0)
1794 hdr->sh_flags |= SHF_ALPHA_GPREL;
1799 /* Hook called by the linker routine which adds symbols from an object
1800 file. We use it to put .comm items in .sbss, and not .bss. */
1803 elf64_alpha_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1805 struct bfd_link_info *info;
1806 const Elf_Internal_Sym *sym;
1812 if (sym->st_shndx == SHN_COMMON
1813 && !info->relocateable
1814 && sym->st_size <= bfd_get_gp_size (abfd))
1816 /* Common symbols less than or equal to -G nn bytes are
1817 automatically put into .sbss. */
1819 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1823 scomm = bfd_make_section (abfd, ".scommon");
1825 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1827 | SEC_LINKER_CREATED)))
1832 *valp = sym->st_size;
1838 /* Create the .got section. */
1841 elf64_alpha_create_got_section(abfd, info)
1843 struct bfd_link_info *info;
1847 if (bfd_get_section_by_name (abfd, ".got"))
1850 s = bfd_make_section (abfd, ".got");
1852 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1855 | SEC_LINKER_CREATED))
1856 || !bfd_set_section_alignment (abfd, s, 3))
1859 alpha_elf_tdata (abfd)->got = s;
1864 /* Create all the dynamic sections. */
1867 elf64_alpha_create_dynamic_sections (abfd, info)
1869 struct bfd_link_info *info;
1872 struct elf_link_hash_entry *h;
1874 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1876 s = bfd_make_section (abfd, ".plt");
1878 || ! bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1881 | SEC_LINKER_CREATED
1883 || ! bfd_set_section_alignment (abfd, s, 3))
1886 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1889 if (! (_bfd_generic_link_add_one_symbol
1890 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1891 (bfd_vma) 0, (const char *) NULL, false,
1892 get_elf_backend_data (abfd)->collect,
1893 (struct bfd_link_hash_entry **) &h)))
1895 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1896 h->type = STT_OBJECT;
1899 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1902 s = bfd_make_section (abfd, ".rela.plt");
1904 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1907 | SEC_LINKER_CREATED
1909 || ! bfd_set_section_alignment (abfd, s, 3))
1912 /* We may or may not have created a .got section for this object, but
1913 we definitely havn't done the rest of the work. */
1915 if (!elf64_alpha_create_got_section (abfd, info))
1918 s = bfd_make_section(abfd, ".rela.got");
1920 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1923 | SEC_LINKER_CREATED
1925 || !bfd_set_section_alignment (abfd, s, 3))
1928 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1929 dynobj's .got section. We don't do this in the linker script
1930 because we don't want to define the symbol if we are not creating
1931 a global offset table. */
1933 if (!(_bfd_generic_link_add_one_symbol
1934 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL,
1935 alpha_elf_tdata(abfd)->got, (bfd_vma) 0, (const char *) NULL,
1936 false, get_elf_backend_data (abfd)->collect,
1937 (struct bfd_link_hash_entry **) &h)))
1939 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1940 h->type = STT_OBJECT;
1943 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
1946 elf_hash_table (info)->hgot = h;
1951 /* Read ECOFF debugging information from a .mdebug section into a
1952 ecoff_debug_info structure. */
1955 elf64_alpha_read_ecoff_info (abfd, section, debug)
1958 struct ecoff_debug_info *debug;
1961 const struct ecoff_debug_swap *swap;
1962 char *ext_hdr = NULL;
1964 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1965 memset (debug, 0, sizeof(*debug));
1967 ext_hdr = (char *) bfd_malloc ((size_t) swap->external_hdr_size);
1968 if (ext_hdr == NULL && swap->external_hdr_size != 0)
1971 if (bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1972 swap->external_hdr_size)
1976 symhdr = &debug->symbolic_header;
1977 (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1979 /* The symbolic header contains absolute file offsets and sizes to
1981 #define READ(ptr, offset, count, size, type) \
1982 if (symhdr->count == 0) \
1983 debug->ptr = NULL; \
1986 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
1987 if (debug->ptr == NULL) \
1988 goto error_return; \
1989 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1990 || (bfd_read (debug->ptr, size, symhdr->count, \
1991 abfd) != size * symhdr->count)) \
1992 goto error_return; \
1995 READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1996 READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, PTR);
1997 READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, PTR);
1998 READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, PTR);
1999 READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, PTR);
2000 READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
2002 READ (ss, cbSsOffset, issMax, sizeof (char), char *);
2003 READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
2004 READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, PTR);
2005 READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, PTR);
2006 READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, PTR);
2010 debug->adjust = NULL;
2015 if (ext_hdr != NULL)
2017 if (debug->line != NULL)
2019 if (debug->external_dnr != NULL)
2020 free (debug->external_dnr);
2021 if (debug->external_pdr != NULL)
2022 free (debug->external_pdr);
2023 if (debug->external_sym != NULL)
2024 free (debug->external_sym);
2025 if (debug->external_opt != NULL)
2026 free (debug->external_opt);
2027 if (debug->external_aux != NULL)
2028 free (debug->external_aux);
2029 if (debug->ss != NULL)
2031 if (debug->ssext != NULL)
2032 free (debug->ssext);
2033 if (debug->external_fdr != NULL)
2034 free (debug->external_fdr);
2035 if (debug->external_rfd != NULL)
2036 free (debug->external_rfd);
2037 if (debug->external_ext != NULL)
2038 free (debug->external_ext);
2042 /* Alpha ELF local labels start with '$'. */
2045 elf64_alpha_is_local_label_name (abfd, name)
2049 return name[0] == '$';
2052 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2053 routine in order to handle the ECOFF debugging information. We
2054 still call this mips_elf_find_line because of the slot
2055 find_line_info in elf_obj_tdata is declared that way. */
2057 struct mips_elf_find_line
2059 struct ecoff_debug_info d;
2060 struct ecoff_find_line i;
2064 elf64_alpha_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2065 functionname_ptr, line_ptr)
2070 const char **filename_ptr;
2071 const char **functionname_ptr;
2072 unsigned int *line_ptr;
2076 msec = bfd_get_section_by_name (abfd, ".mdebug");
2080 struct mips_elf_find_line *fi;
2081 const struct ecoff_debug_swap * const swap =
2082 get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
2084 /* If we are called during a link, alpha_elf_final_link may have
2085 cleared the SEC_HAS_CONTENTS field. We force it back on here
2086 if appropriate (which it normally will be). */
2087 origflags = msec->flags;
2088 if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
2089 msec->flags |= SEC_HAS_CONTENTS;
2091 fi = elf_tdata (abfd)->find_line_info;
2094 bfd_size_type external_fdr_size;
2097 struct fdr *fdr_ptr;
2099 fi = ((struct mips_elf_find_line *)
2100 bfd_zalloc (abfd, sizeof (struct mips_elf_find_line)));
2103 msec->flags = origflags;
2107 if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
2109 msec->flags = origflags;
2113 /* Swap in the FDR information. */
2114 fi->d.fdr = ((struct fdr *)
2116 (fi->d.symbolic_header.ifdMax *
2117 sizeof (struct fdr))));
2118 if (fi->d.fdr == NULL)
2120 msec->flags = origflags;
2123 external_fdr_size = swap->external_fdr_size;
2124 fdr_ptr = fi->d.fdr;
2125 fraw_src = (char *) fi->d.external_fdr;
2126 fraw_end = (fraw_src
2127 + fi->d.symbolic_header.ifdMax * external_fdr_size);
2128 for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
2129 (*swap->swap_fdr_in) (abfd, (PTR) fraw_src, fdr_ptr);
2131 elf_tdata (abfd)->find_line_info = fi;
2133 /* Note that we don't bother to ever free this information.
2134 find_nearest_line is either called all the time, as in
2135 objdump -l, so the information should be saved, or it is
2136 rarely called, as in ld error messages, so the memory
2137 wasted is unimportant. Still, it would probably be a
2138 good idea for free_cached_info to throw it away. */
2141 if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
2142 &fi->i, filename_ptr, functionname_ptr,
2145 msec->flags = origflags;
2149 msec->flags = origflags;
2152 /* Fall back on the generic ELF find_nearest_line routine. */
2154 return _bfd_elf_find_nearest_line (abfd, section, symbols, offset,
2155 filename_ptr, functionname_ptr,
2159 /* Structure used to pass information to alpha_elf_output_extsym. */
2164 struct bfd_link_info *info;
2165 struct ecoff_debug_info *debug;
2166 const struct ecoff_debug_swap *swap;
2171 elf64_alpha_output_extsym (h, data)
2172 struct alpha_elf_link_hash_entry *h;
2175 struct extsym_info *einfo = (struct extsym_info *) data;
2177 asection *sec, *output_section;
2179 if (h->root.indx == -2)
2181 else if (((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2182 || (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0)
2183 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
2184 && (h->root.elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
2186 else if (einfo->info->strip == strip_all
2187 || (einfo->info->strip == strip_some
2188 && bfd_hash_lookup (einfo->info->keep_hash,
2189 h->root.root.root.string,
2190 false, false) == NULL))
2198 if (h->esym.ifd == -2)
2201 h->esym.cobol_main = 0;
2202 h->esym.weakext = 0;
2203 h->esym.reserved = 0;
2204 h->esym.ifd = ifdNil;
2205 h->esym.asym.value = 0;
2206 h->esym.asym.st = stGlobal;
2208 if (h->root.root.type != bfd_link_hash_defined
2209 && h->root.root.type != bfd_link_hash_defweak)
2210 h->esym.asym.sc = scAbs;
2215 sec = h->root.root.u.def.section;
2216 output_section = sec->output_section;
2218 /* When making a shared library and symbol h is the one from
2219 the another shared library, OUTPUT_SECTION may be null. */
2220 if (output_section == NULL)
2221 h->esym.asym.sc = scUndefined;
2224 name = bfd_section_name (output_section->owner, output_section);
2226 if (strcmp (name, ".text") == 0)
2227 h->esym.asym.sc = scText;
2228 else if (strcmp (name, ".data") == 0)
2229 h->esym.asym.sc = scData;
2230 else if (strcmp (name, ".sdata") == 0)
2231 h->esym.asym.sc = scSData;
2232 else if (strcmp (name, ".rodata") == 0
2233 || strcmp (name, ".rdata") == 0)
2234 h->esym.asym.sc = scRData;
2235 else if (strcmp (name, ".bss") == 0)
2236 h->esym.asym.sc = scBss;
2237 else if (strcmp (name, ".sbss") == 0)
2238 h->esym.asym.sc = scSBss;
2239 else if (strcmp (name, ".init") == 0)
2240 h->esym.asym.sc = scInit;
2241 else if (strcmp (name, ".fini") == 0)
2242 h->esym.asym.sc = scFini;
2244 h->esym.asym.sc = scAbs;
2248 h->esym.asym.reserved = 0;
2249 h->esym.asym.index = indexNil;
2252 if (h->root.root.type == bfd_link_hash_common)
2253 h->esym.asym.value = h->root.root.u.c.size;
2254 else if (h->root.root.type == bfd_link_hash_defined
2255 || h->root.root.type == bfd_link_hash_defweak)
2257 if (h->esym.asym.sc == scCommon)
2258 h->esym.asym.sc = scBss;
2259 else if (h->esym.asym.sc == scSCommon)
2260 h->esym.asym.sc = scSBss;
2262 sec = h->root.root.u.def.section;
2263 output_section = sec->output_section;
2264 if (output_section != NULL)
2265 h->esym.asym.value = (h->root.root.u.def.value
2266 + sec->output_offset
2267 + output_section->vma);
2269 h->esym.asym.value = 0;
2271 else if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2273 /* Set type and value for a symbol with a function stub. */
2274 h->esym.asym.st = stProc;
2275 sec = bfd_get_section_by_name (einfo->abfd, ".plt");
2277 h->esym.asym.value = 0;
2280 output_section = sec->output_section;
2281 if (output_section != NULL)
2282 h->esym.asym.value = (h->root.plt.offset
2283 + sec->output_offset
2284 + output_section->vma);
2286 h->esym.asym.value = 0;
2293 if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
2294 h->root.root.root.string,
2297 einfo->failed = true;
2304 /* FIXME: Create a runtime procedure table from the .mdebug section.
2307 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2310 struct bfd_link_info *info;
2312 struct ecoff_debug_info *debug;
2315 /* Handle dynamic relocations when doing an Alpha ELF link. */
2318 elf64_alpha_check_relocs (abfd, info, sec, relocs)
2320 struct bfd_link_info *info;
2322 const Elf_Internal_Rela *relocs;
2326 const char *rel_sec_name;
2327 Elf_Internal_Shdr *symtab_hdr;
2328 struct alpha_elf_link_hash_entry **sym_hashes;
2329 struct alpha_elf_got_entry **local_got_entries;
2330 const Elf_Internal_Rela *rel, *relend;
2333 if (info->relocateable)
2336 dynobj = elf_hash_table(info)->dynobj;
2338 elf_hash_table(info)->dynobj = dynobj = abfd;
2341 rel_sec_name = NULL;
2342 symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
2343 sym_hashes = alpha_elf_sym_hashes(abfd);
2344 local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
2347 relend = relocs + sec->reloc_count;
2348 for (rel = relocs; rel < relend; ++rel)
2350 unsigned long r_symndx, r_type;
2351 struct alpha_elf_link_hash_entry *h;
2353 r_symndx = ELF64_R_SYM (rel->r_info);
2354 if (r_symndx < symtab_hdr->sh_info)
2358 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2360 while (h->root.root.type == bfd_link_hash_indirect
2361 || h->root.root.type == bfd_link_hash_warning)
2362 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2364 h->root.elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2366 r_type = ELF64_R_TYPE (rel->r_info);
2370 case R_ALPHA_LITERAL:
2372 struct alpha_elf_got_entry *gotent;
2377 /* Search for and possibly create a got entry. */
2378 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2379 if (gotent->gotobj == abfd &&
2380 gotent->addend == rel->r_addend)
2385 gotent = ((struct alpha_elf_got_entry *)
2387 sizeof (struct alpha_elf_got_entry)));
2391 gotent->gotobj = abfd;
2392 gotent->addend = rel->r_addend;
2393 gotent->got_offset = -1;
2395 gotent->use_count = 1;
2397 gotent->next = h->got_entries;
2398 h->got_entries = gotent;
2400 alpha_elf_tdata (abfd)->total_got_entries++;
2403 gotent->use_count += 1;
2407 /* This is a local .got entry -- record for merge. */
2408 if (!local_got_entries)
2411 size = (symtab_hdr->sh_info
2412 * sizeof (struct alpha_elf_got_entry *));
2414 local_got_entries = ((struct alpha_elf_got_entry **)
2415 bfd_alloc (abfd, size));
2416 if (!local_got_entries)
2419 memset (local_got_entries, 0, size);
2420 alpha_elf_tdata (abfd)->local_got_entries =
2424 for (gotent = local_got_entries[ELF64_R_SYM(rel->r_info)];
2425 gotent != NULL && gotent->addend != rel->r_addend;
2426 gotent = gotent->next)
2430 gotent = ((struct alpha_elf_got_entry *)
2432 sizeof (struct alpha_elf_got_entry)));
2436 gotent->gotobj = abfd;
2437 gotent->addend = rel->r_addend;
2438 gotent->got_offset = -1;
2440 gotent->use_count = 1;
2442 gotent->next = local_got_entries[ELF64_R_SYM(rel->r_info)];
2443 local_got_entries[ELF64_R_SYM(rel->r_info)] = gotent;
2445 alpha_elf_tdata(abfd)->total_got_entries++;
2446 alpha_elf_tdata(abfd)->n_local_got_entries++;
2449 gotent->use_count += 1;
2452 /* Remember how this literal is used from its LITUSEs.
2453 This will be important when it comes to decide if we can
2454 create a .plt entry for a function symbol. */
2456 && ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE)
2461 if (rel->r_addend >= 1 && rel->r_addend <= 3)
2462 flags |= 1 << rel->r_addend;
2464 while (rel+1 < relend &&
2465 ELF64_R_TYPE (rel[1].r_info) == R_ALPHA_LITUSE);
2469 /* No LITUSEs -- presumably the address is not being
2470 loaded for nothing. */
2471 flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
2474 gotent->flags |= flags;
2477 /* Make a guess as to whether a .plt entry will be needed. */
2478 if ((h->flags |= flags) == ALPHA_ELF_LINK_HASH_LU_FUNC)
2479 h->root.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2481 h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2486 case R_ALPHA_GPDISP:
2487 case R_ALPHA_GPREL32:
2488 case R_ALPHA_GPRELHIGH:
2489 case R_ALPHA_GPRELLOW:
2490 /* We don't actually use the .got here, but the sections must
2491 be created before the linker maps input sections to output
2495 if (!elf64_alpha_create_got_section (abfd, info))
2498 /* Make sure the object's gotobj is set to itself so
2499 that we default to every object with its own .got.
2500 We'll merge .gots later once we've collected each
2502 alpha_elf_tdata(abfd)->gotobj = abfd;
2508 case R_ALPHA_SREL16:
2509 case R_ALPHA_SREL32:
2510 case R_ALPHA_SREL64:
2515 case R_ALPHA_REFLONG:
2516 case R_ALPHA_REFQUAD:
2517 if (rel_sec_name == NULL)
2519 rel_sec_name = (bfd_elf_string_from_elf_section
2520 (abfd, elf_elfheader(abfd)->e_shstrndx,
2521 elf_section_data(sec)->rel_hdr.sh_name));
2522 if (rel_sec_name == NULL)
2525 BFD_ASSERT (strncmp (rel_sec_name, ".rela", 5) == 0
2526 && strcmp (bfd_get_section_name (abfd, sec),
2527 rel_sec_name+5) == 0);
2530 /* We need to create the section here now whether we eventually
2531 use it or not so that it gets mapped to an output section by
2532 the linker. If not used, we'll kill it in
2533 size_dynamic_sections. */
2536 sreloc = bfd_get_section_by_name (dynobj, rel_sec_name);
2539 sreloc = bfd_make_section (dynobj, rel_sec_name);
2541 || !bfd_set_section_flags (dynobj, sreloc,
2545 | SEC_LINKER_CREATED
2547 || !bfd_set_section_alignment (dynobj, sreloc, 3))
2554 /* Since we havn't seen all of the input symbols yet, we
2555 don't know whether we'll actually need a dynamic relocation
2556 entry for this reloc. So make a record of it. Once we
2557 find out if this thing needs dynamic relocation we'll
2558 expand the relocation sections by the appropriate amount. */
2560 struct alpha_elf_reloc_entry *rent;
2562 for (rent = h->reloc_entries; rent; rent = rent->next)
2563 if (rent->rtype == r_type && rent->srel == sreloc)
2568 rent = ((struct alpha_elf_reloc_entry *)
2570 sizeof (struct alpha_elf_reloc_entry)));
2574 rent->srel = sreloc;
2575 rent->rtype = r_type;
2578 rent->next = h->reloc_entries;
2579 h->reloc_entries = rent;
2584 else if (info->shared && (sec->flags & SEC_ALLOC))
2586 /* If this is a shared library, and the section is to be
2587 loaded into memory, we need a RELATIVE reloc. */
2588 sreloc->_raw_size += sizeof (Elf64_External_Rela);
2597 /* Adjust a symbol defined by a dynamic object and referenced by a
2598 regular object. The current definition is in some section of the
2599 dynamic object, but we're not including those sections. We have to
2600 change the definition to something the rest of the link can
2604 elf64_alpha_adjust_dynamic_symbol (info, h)
2605 struct bfd_link_info *info;
2606 struct elf_link_hash_entry *h;
2610 struct alpha_elf_link_hash_entry *ah;
2612 dynobj = elf_hash_table(info)->dynobj;
2613 ah = (struct alpha_elf_link_hash_entry *)h;
2615 /* Now that we've seen all of the input symbols, finalize our decision
2616 about whether this symbol should get a .plt entry. */
2618 if (h->root.type != bfd_link_hash_undefweak
2619 && alpha_elf_dynamic_symbol_p (h, info)
2620 && ((h->type == STT_FUNC
2621 && !(ah->flags & ALPHA_ELF_LINK_HASH_LU_ADDR))
2622 || (h->type == STT_NOTYPE
2623 && ah->flags == ALPHA_ELF_LINK_HASH_LU_FUNC))
2624 /* Don't prevent otherwise valid programs from linking by attempting
2625 to create a new .got entry somewhere. A Correct Solution would be
2626 to add a new .got section to a new object file and let it be merged
2627 somewhere later. But for now don't bother. */
2630 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2632 s = bfd_get_section_by_name(dynobj, ".plt");
2633 if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2636 /* The first bit of the .plt is reserved. */
2637 if (s->_raw_size == 0)
2638 s->_raw_size = PLT_HEADER_SIZE;
2640 h->plt.offset = s->_raw_size;
2641 s->_raw_size += PLT_ENTRY_SIZE;
2643 /* If this symbol is not defined in a regular file, and we are not
2644 generating a shared library, then set the symbol to the location
2645 in the .plt. This is required to make function pointers compare
2646 equal between the normal executable and the shared library. */
2648 && h->root.type != bfd_link_hash_defweak)
2650 h->root.u.def.section = s;
2651 h->root.u.def.value = h->plt.offset;
2654 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2655 s = bfd_get_section_by_name (dynobj, ".rela.plt");
2656 BFD_ASSERT (s != NULL);
2657 s->_raw_size += sizeof (Elf64_External_Rela);
2662 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2664 /* If this is a weak symbol, and there is a real definition, the
2665 processor independent code will have arranged for us to see the
2666 real definition first, and we can just use the same value. */
2667 if (h->weakdef != NULL)
2669 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2670 || h->weakdef->root.type == bfd_link_hash_defweak);
2671 h->root.u.def.section = h->weakdef->root.u.def.section;
2672 h->root.u.def.value = h->weakdef->root.u.def.value;
2676 /* This is a reference to a symbol defined by a dynamic object which
2677 is not a function. The Alpha, since it uses .got entries for all
2678 symbols even in regular objects, does not need the hackery of a
2679 .dynbss section and COPY dynamic relocations. */
2684 /* Symbol versioning can create new symbols, and make our old symbols
2685 indirect to the new ones. Consolidate the got and reloc information
2686 in these situations. */
2689 elf64_alpha_merge_ind_symbols (hi, dummy)
2690 struct alpha_elf_link_hash_entry *hi;
2693 struct alpha_elf_link_hash_entry *hs;
2695 if (hi->root.root.type != bfd_link_hash_indirect)
2699 hs = (struct alpha_elf_link_hash_entry *)hs->root.root.u.i.link;
2700 } while (hs->root.root.type == bfd_link_hash_indirect);
2702 /* Merge the flags. Whee. */
2704 hs->flags |= hi->flags;
2706 /* Merge the .got entries. Cannibalize the old symbol's list in
2707 doing so, since we don't need it anymore. */
2709 if (hs->got_entries == NULL)
2710 hs->got_entries = hi->got_entries;
2713 struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2715 gsh = hs->got_entries;
2716 for (gi = hi->got_entries; gi ; gi = gin)
2719 for (gs = gsh; gs ; gs = gs->next)
2720 if (gi->gotobj == gs->gotobj && gi->addend == gs->addend)
2722 gi->next = hs->got_entries;
2723 hs->got_entries = gi;
2727 hi->got_entries = NULL;
2729 /* And similar for the reloc entries. */
2731 if (hs->reloc_entries == NULL)
2732 hs->reloc_entries = hi->reloc_entries;
2735 struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2737 rsh = hs->reloc_entries;
2738 for (ri = hi->reloc_entries; ri ; ri = rin)
2741 for (rs = rsh; rs ; rs = rs->next)
2742 if (ri->rtype == rs->rtype)
2744 rs->count += ri->count;
2747 ri->next = hs->reloc_entries;
2748 hs->reloc_entries = ri;
2752 hi->reloc_entries = NULL;
2757 /* Is it possible to merge two object file's .got tables? */
2760 elf64_alpha_can_merge_gots (a, b)
2763 int total = alpha_elf_tdata (a)->total_got_entries;
2766 /* Trivial quick fallout test. */
2767 if (total + alpha_elf_tdata (b)->total_got_entries <= MAX_GOT_ENTRIES)
2770 /* By their nature, local .got entries cannot be merged. */
2771 if ((total += alpha_elf_tdata (b)->n_local_got_entries) > MAX_GOT_ENTRIES)
2774 /* Failing the common trivial comparison, we must effectively
2775 perform the merge. Not actually performing the merge means that
2776 we don't have to store undo information in case we fail. */
2777 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2779 struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2780 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2783 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2784 for (i = 0; i < n; ++i)
2786 struct alpha_elf_got_entry *ae, *be;
2787 struct alpha_elf_link_hash_entry *h;
2790 while (h->root.root.type == bfd_link_hash_indirect
2791 || h->root.root.type == bfd_link_hash_warning)
2792 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2794 for (be = h->got_entries; be ; be = be->next)
2796 if (be->use_count == 0)
2798 if (be->gotobj != b)
2801 for (ae = h->got_entries; ae ; ae = ae->next)
2802 if (ae->gotobj == a && ae->addend == be->addend)
2805 if (++total > MAX_GOT_ENTRIES)
2815 /* Actually merge two .got tables. */
2818 elf64_alpha_merge_gots (a, b)
2821 int total = alpha_elf_tdata (a)->total_got_entries;
2824 /* Remember local expansion. */
2826 int e = alpha_elf_tdata (b)->n_local_got_entries;
2828 alpha_elf_tdata (a)->n_local_got_entries += e;
2831 for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2833 struct alpha_elf_got_entry **local_got_entries;
2834 struct alpha_elf_link_hash_entry **hashes;
2835 Elf_Internal_Shdr *symtab_hdr;
2838 /* Let the local .got entries know they are part of a new subsegment. */
2839 local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2840 if (local_got_entries)
2842 n = elf_tdata (bsub)->symtab_hdr.sh_info;
2843 for (i = 0; i < n; ++i)
2845 struct alpha_elf_got_entry *ent;
2846 for (ent = local_got_entries[i]; ent; ent = ent->next)
2851 /* Merge the global .got entries. */
2852 hashes = alpha_elf_sym_hashes (bsub);
2853 symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2855 n = symtab_hdr->sh_size / symtab_hdr->sh_entsize - symtab_hdr->sh_info;
2856 for (i = 0; i < n; ++i)
2858 struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2859 struct alpha_elf_link_hash_entry *h;
2862 while (h->root.root.type == bfd_link_hash_indirect
2863 || h->root.root.type == bfd_link_hash_warning)
2864 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2866 start = &h->got_entries;
2867 for (pbe = start, be = *start; be ; pbe = &be->next, be = be->next)
2869 if (be->use_count == 0)
2874 if (be->gotobj != b)
2877 for (ae = *start; ae ; ae = ae->next)
2878 if (ae->gotobj == a && ae->addend == be->addend)
2880 ae->flags |= be->flags;
2881 ae->use_count += be->use_count;
2892 alpha_elf_tdata (bsub)->gotobj = a;
2894 alpha_elf_tdata (a)->total_got_entries = total;
2896 /* Merge the two in_got chains. */
2901 while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2904 alpha_elf_tdata (bsub)->in_got_link_next = b;
2908 /* Calculate the offsets for the got entries. */
2911 elf64_alpha_calc_got_offsets_for_symbol (h, arg)
2912 struct alpha_elf_link_hash_entry *h;
2915 struct alpha_elf_got_entry *gotent;
2917 for (gotent = h->got_entries; gotent; gotent = gotent->next)
2918 if (gotent->use_count > 0)
2921 = &alpha_elf_tdata (gotent->gotobj)->got->_raw_size;
2923 gotent->got_offset = *plge;
2931 elf64_alpha_calc_got_offsets (info)
2932 struct bfd_link_info *info;
2934 bfd *i, *got_list = alpha_elf_hash_table(info)->got_list;
2936 /* First, zero out the .got sizes, as we may be recalculating the
2937 .got after optimizing it. */
2938 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2939 alpha_elf_tdata(i)->got->_raw_size = 0;
2941 /* Next, fill in the offsets for all the global entries. */
2942 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
2943 elf64_alpha_calc_got_offsets_for_symbol,
2946 /* Finally, fill in the offsets for the local entries. */
2947 for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2949 bfd_size_type got_offset = alpha_elf_tdata(i)->got->_raw_size;
2952 for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2954 struct alpha_elf_got_entry **local_got_entries, *gotent;
2957 local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2958 if (!local_got_entries)
2961 for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2962 for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2963 if (gotent->use_count > 0)
2965 gotent->got_offset = got_offset;
2970 alpha_elf_tdata(i)->got->_raw_size = got_offset;
2971 alpha_elf_tdata(i)->got->_cooked_size = got_offset;
2975 /* Constructs the gots. */
2978 elf64_alpha_size_got_sections (output_bfd, info)
2980 struct bfd_link_info *info;
2982 bfd *i, *got_list, *cur_got_obj;
2983 int something_changed = 0;
2985 got_list = alpha_elf_hash_table (info)->got_list;
2987 /* On the first time through, pretend we have an existing got list
2988 consisting of all of the input files. */
2989 if (got_list == NULL)
2991 for (i = info->input_bfds; i ; i = i->link_next)
2993 bfd *this_got = alpha_elf_tdata (i)->gotobj;
2994 if (this_got == NULL)
2997 /* We are assuming no merging has yet ocurred. */
2998 BFD_ASSERT (this_got == i);
3000 if (alpha_elf_tdata (this_got)->total_got_entries > MAX_GOT_ENTRIES)
3002 /* Yikes! A single object file has too many entries. */
3003 (*_bfd_error_handler)
3004 (_("%s: .got subsegment exceeds 64K (size %d)"),
3005 bfd_get_filename (i),
3006 alpha_elf_tdata (this_got)->total_got_entries * 8);
3010 if (got_list == NULL)
3011 got_list = this_got;
3013 alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
3014 cur_got_obj = this_got;
3017 /* Strange degenerate case of no got references. */
3018 if (got_list == NULL)
3021 alpha_elf_hash_table (info)->got_list = got_list;
3023 /* Force got offsets to be recalculated. */
3024 something_changed = 1;
3027 cur_got_obj = got_list;
3028 i = alpha_elf_tdata(cur_got_obj)->got_link_next;
3031 if (elf64_alpha_can_merge_gots (cur_got_obj, i))
3033 elf64_alpha_merge_gots (cur_got_obj, i);
3034 i = alpha_elf_tdata(i)->got_link_next;
3035 alpha_elf_tdata(cur_got_obj)->got_link_next = i;
3036 something_changed = 1;
3041 i = alpha_elf_tdata(i)->got_link_next;
3045 /* Once the gots have been merged, fill in the got offsets for
3046 everything therein. */
3047 if (1 || something_changed)
3048 elf64_alpha_calc_got_offsets (info);
3054 elf64_alpha_always_size_sections (output_bfd, info)
3056 struct bfd_link_info *info;
3060 if (info->relocateable)
3063 /* First, take care of the indirect symbols created by versioning. */
3064 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3065 elf64_alpha_merge_ind_symbols,
3068 if (!elf64_alpha_size_got_sections (output_bfd, info))
3071 /* Allocate space for all of the .got subsections. */
3072 i = alpha_elf_hash_table (info)->got_list;
3073 for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
3075 asection *s = alpha_elf_tdata(i)->got;
3076 if (s->_raw_size > 0)
3078 s->contents = (bfd_byte *) bfd_zalloc (i, s->_raw_size);
3079 if (s->contents == NULL)
3087 /* Work out the sizes of the dynamic relocation entries. */
3090 elf64_alpha_calc_dynrel_sizes (h, info)
3091 struct alpha_elf_link_hash_entry *h;
3092 struct bfd_link_info *info;
3094 /* If the symbol was defined as a common symbol in a regular object
3095 file, and there was no definition in any dynamic object, then the
3096 linker will have allocated space for the symbol in a common
3097 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3098 set. This is done for dynamic symbols in
3099 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3100 symbols, somehow. */
3101 if (((h->root.elf_link_hash_flags
3102 & (ELF_LINK_HASH_DEF_REGULAR
3103 | ELF_LINK_HASH_REF_REGULAR
3104 | ELF_LINK_HASH_DEF_DYNAMIC))
3105 == ELF_LINK_HASH_REF_REGULAR)
3106 && (h->root.root.type == bfd_link_hash_defined
3107 || h->root.root.type == bfd_link_hash_defweak)
3108 && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
3110 h->root.elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3113 /* If the symbol is dynamic, we'll need all the relocations in their
3114 natural form. If this is a shared object, and it has been forced
3115 local, we'll need the same number of RELATIVE relocations. */
3117 if (alpha_elf_dynamic_symbol_p (&h->root, info) || info->shared)
3119 struct alpha_elf_reloc_entry *relent;
3121 struct alpha_elf_got_entry *gotent;
3122 bfd_size_type count;
3125 for (relent = h->reloc_entries; relent; relent = relent->next)
3126 if (relent->rtype == R_ALPHA_REFLONG
3127 || relent->rtype == R_ALPHA_REFQUAD)
3129 relent->srel->_raw_size +=
3130 sizeof(Elf64_External_Rela) * relent->count;
3133 dynobj = elf_hash_table(info)->dynobj;
3136 for (gotent = h->got_entries; gotent ; gotent = gotent->next)
3139 /* If we are using a .plt entry, subtract one, as the first
3140 reference uses a .rela.plt entry instead. */
3141 if (h->root.plt.offset != MINUS_ONE)
3146 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3147 BFD_ASSERT (srel != NULL);
3148 srel->_raw_size += sizeof (Elf64_External_Rela) * count;
3155 /* Set the sizes of the dynamic sections. */
3158 elf64_alpha_size_dynamic_sections (output_bfd, info)
3160 struct bfd_link_info *info;
3167 dynobj = elf_hash_table(info)->dynobj;
3168 BFD_ASSERT(dynobj != NULL);
3170 if (elf_hash_table (info)->dynamic_sections_created)
3172 /* Set the contents of the .interp section to the interpreter. */
3175 s = bfd_get_section_by_name (dynobj, ".interp");
3176 BFD_ASSERT (s != NULL);
3177 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3178 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3181 /* Now that we've seen all of the input files, we can decide which
3182 symbols need dynamic relocation entries and which don't. We've
3183 collected information in check_relocs that we can now apply to
3184 size the dynamic relocation sections. */
3185 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info),
3186 elf64_alpha_calc_dynrel_sizes,
3189 /* When building shared libraries, each local .got entry needs a
3195 bfd_size_type count;
3197 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3198 BFD_ASSERT (srel != NULL);
3200 for (i = alpha_elf_hash_table(info)->got_list, count = 0;
3202 i = alpha_elf_tdata(i)->got_link_next)
3203 count += alpha_elf_tdata(i)->n_local_got_entries;
3205 srel->_raw_size += count * sizeof(Elf64_External_Rela);
3208 /* else we're not dynamic and by definition we don't need such things. */
3210 /* The check_relocs and adjust_dynamic_symbol entry points have
3211 determined the sizes of the various dynamic sections. Allocate
3215 for (s = dynobj->sections; s != NULL; s = s->next)
3220 if (!(s->flags & SEC_LINKER_CREATED))
3223 /* It's OK to base decisions on the section name, because none
3224 of the dynobj section names depend upon the input files. */
3225 name = bfd_get_section_name (dynobj, s);
3227 /* If we don't need this section, strip it from the output file.
3228 This is to handle .rela.bss and .rela.plt. We must create it
3229 in create_dynamic_sections, because it must be created before
3230 the linker maps input sections to output sections. The
3231 linker does that before adjust_dynamic_symbol is called, and
3232 it is that function which decides whether anything needs to
3233 go into these sections. */
3237 if (strncmp (name, ".rela", 5) == 0)
3239 strip = (s->_raw_size == 0);
3243 const char *outname;
3246 /* If this relocation section applies to a read only
3247 section, then we probably need a DT_TEXTREL entry. */
3248 outname = bfd_get_section_name (output_bfd,
3250 target = bfd_get_section_by_name (output_bfd, outname + 5);
3252 && (target->flags & SEC_READONLY) != 0
3253 && (target->flags & SEC_ALLOC) != 0)
3256 if (strcmp(name, ".rela.plt") == 0)
3259 /* We use the reloc_count field as a counter if we need
3260 to copy relocs into the output file. */
3264 else if (strcmp (name, ".plt") != 0)
3266 /* It's not one of our dynamic sections, so don't allocate space. */
3271 _bfd_strip_section_from_output (info, s);
3274 /* Allocate memory for the section contents. */
3275 s->contents = (bfd_byte *) bfd_zalloc(dynobj, s->_raw_size);
3276 if (s->contents == NULL && s->_raw_size != 0)
3281 if (elf_hash_table (info)->dynamic_sections_created)
3283 /* Add some entries to the .dynamic section. We fill in the
3284 values later, in elf64_alpha_finish_dynamic_sections, but we
3285 must add the entries now so that we get the correct size for
3286 the .dynamic section. The DT_DEBUG entry is filled in by the
3287 dynamic linker and used by the debugger. */
3290 if (!bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0))
3294 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
3299 if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3300 || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
3301 || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
3305 if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
3306 || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
3307 || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
3308 sizeof(Elf64_External_Rela)))
3313 if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
3315 info->flags |= DF_TEXTREL;
3322 /* Relocate an Alpha ELF section. */
3325 elf64_alpha_relocate_section (output_bfd, info, input_bfd, input_section,
3326 contents, relocs, local_syms, local_sections)
3328 struct bfd_link_info *info;
3330 asection *input_section;
3332 Elf_Internal_Rela *relocs;
3333 Elf_Internal_Sym *local_syms;
3334 asection **local_sections;
3336 Elf_Internal_Shdr *symtab_hdr;
3337 Elf_Internal_Rela *rel;
3338 Elf_Internal_Rela *relend;
3339 asection *sec, *sgot, *srel, *srelgot;
3340 bfd *dynobj, *gotobj;
3343 srelgot = srel = NULL;
3344 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3345 dynobj = elf_hash_table (info)->dynobj;
3348 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3351 /* Find the gp value for this input bfd. */
3354 gotobj = alpha_elf_tdata (input_bfd)->gotobj;
3357 sgot = alpha_elf_tdata (gotobj)->got;
3358 gp = _bfd_get_gp_value (gotobj);
3361 gp = (sgot->output_section->vma
3362 + sgot->output_offset
3364 _bfd_set_gp_value (gotobj, gp);
3369 relend = relocs + input_section->reloc_count;
3370 for (; rel < relend; rel++)
3373 reloc_howto_type *howto;
3374 unsigned long r_symndx;
3375 struct alpha_elf_link_hash_entry *h;
3376 Elf_Internal_Sym *sym;
3379 bfd_reloc_status_type r;
3381 r_type = ELF64_R_TYPE(rel->r_info);
3382 if (r_type < 0 || r_type >= (int) R_ALPHA_max)
3384 bfd_set_error (bfd_error_bad_value);
3387 howto = elf64_alpha_howto_table + r_type;
3389 r_symndx = ELF64_R_SYM(rel->r_info);
3391 if (info->relocateable)
3393 /* This is a relocateable link. We don't have to change
3394 anything, unless the reloc is against a section symbol,
3395 in which case we have to adjust according to where the
3396 section symbol winds up in the output section. */
3398 /* The symbol associated with GPDISP and LITUSE is
3399 immaterial. Only the addend is significant. */
3400 if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
3403 if (r_symndx < symtab_hdr->sh_info)
3405 sym = local_syms + r_symndx;
3406 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
3408 sec = local_sections[r_symndx];
3409 rel->r_addend += sec->output_offset + sym->st_value;
3416 /* This is a final link. */
3422 if (r_symndx < symtab_hdr->sh_info)
3424 sym = local_syms + r_symndx;
3425 sec = local_sections[r_symndx];
3426 relocation = (sec->output_section->vma
3427 + sec->output_offset
3432 h = alpha_elf_sym_hashes (input_bfd)[r_symndx - symtab_hdr->sh_info];
3434 while (h->root.root.type == bfd_link_hash_indirect
3435 || h->root.root.type == bfd_link_hash_warning)
3436 h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3438 if (h->root.root.type == bfd_link_hash_defined
3439 || h->root.root.type == bfd_link_hash_defweak)
3441 sec = h->root.root.u.def.section;
3444 if ((r_type == R_ALPHA_LITERAL
3445 && elf_hash_table(info)->dynamic_sections_created
3448 || !(h->root.elf_link_hash_flags
3449 & ELF_LINK_HASH_DEF_REGULAR)))
3452 || !(h->root.elf_link_hash_flags
3453 & ELF_LINK_HASH_DEF_REGULAR))
3454 && (input_section->flags & SEC_ALLOC)
3455 && (r_type == R_ALPHA_REFLONG
3456 || r_type == R_ALPHA_REFQUAD
3457 || r_type == R_ALPHA_LITERAL)))
3459 /* In these cases, we don't need the relocation value.
3460 We check specially because in some obscure cases
3461 sec->output_section will be NULL. */
3465 /* FIXME: Are not these obscure cases simply bugs? Let's
3466 get something working and come back to this. */
3467 if (sec->output_section == NULL)
3469 #endif /* rth_notdef */
3472 relocation = (h->root.root.u.def.value
3473 + sec->output_section->vma
3474 + sec->output_offset);
3477 else if (h->root.root.type == bfd_link_hash_undefweak)
3479 else if (info->shared && !info->symbolic
3480 && !info->no_undefined
3481 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
3485 if (!((*info->callbacks->undefined_symbol)
3486 (info, h->root.root.root.string, input_bfd,
3487 input_section, rel->r_offset,
3488 (!info->shared || info->no_undefined
3489 || ELF_ST_VISIBILITY (h->root.other)))))
3494 addend = rel->r_addend;
3498 case R_ALPHA_GPDISP:
3500 bfd_byte *p_ldah, *p_lda;
3502 BFD_ASSERT(gp != 0);
3504 relocation = (input_section->output_section->vma
3505 + input_section->output_offset
3508 p_ldah = contents + rel->r_offset - input_section->vma;
3509 p_lda = p_ldah + rel->r_addend;
3511 r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - relocation,
3516 case R_ALPHA_OP_PUSH:
3517 case R_ALPHA_OP_STORE:
3518 case R_ALPHA_OP_PSUB:
3519 case R_ALPHA_OP_PRSHIFT:
3520 /* We hate these silly beasts. */
3523 case R_ALPHA_LITERAL:
3525 struct alpha_elf_got_entry *gotent;
3526 boolean dynamic_symbol;
3528 BFD_ASSERT(sgot != NULL);
3529 BFD_ASSERT(gp != 0);
3533 gotent = h->got_entries;
3534 dynamic_symbol = alpha_elf_dynamic_symbol_p (&h->root, info);
3538 gotent = (alpha_elf_tdata(input_bfd)->
3539 local_got_entries[r_symndx]);
3540 dynamic_symbol = false;
3543 BFD_ASSERT(gotent != NULL);
3545 while (gotent->gotobj != gotobj || gotent->addend != addend)
3546 gotent = gotent->next;
3548 BFD_ASSERT(gotent->use_count >= 1);
3550 /* Initialize the .got entry's value. */
3551 if (!(gotent->flags & ALPHA_ELF_GOT_ENTRY_RELOCS_DONE))
3553 bfd_put_64 (output_bfd, relocation+addend,
3554 sgot->contents + gotent->got_offset);
3556 /* If the symbol has been forced local, output a
3557 RELATIVE reloc, otherwise it will be handled in
3558 finish_dynamic_symbol. */
3559 if (info->shared && !dynamic_symbol)
3561 Elf_Internal_Rela outrel;
3563 BFD_ASSERT(srelgot != NULL);
3565 outrel.r_offset = (sgot->output_section->vma
3566 + sgot->output_offset
3567 + gotent->got_offset);
3568 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3569 outrel.r_addend = 0;
3571 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3572 ((Elf64_External_Rela *)
3574 + srelgot->reloc_count++);
3575 BFD_ASSERT (sizeof(Elf64_External_Rela)
3576 * srelgot->reloc_count
3577 <= srelgot->_cooked_size);
3580 gotent->flags |= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE;
3583 /* Figure the gprel relocation. */
3585 relocation = (sgot->output_section->vma
3586 + sgot->output_offset
3587 + gotent->got_offset);
3590 /* overflow handled by _bfd_final_link_relocate */
3593 case R_ALPHA_GPREL32:
3594 case R_ALPHA_GPRELLOW:
3595 BFD_ASSERT(gp != 0);
3599 case R_ALPHA_GPRELHIGH:
3600 BFD_ASSERT(gp != 0);
3602 relocation += addend;
3604 relocation = (((bfd_signed_vma) relocation >> 16)
3605 + ((relocation >> 15) & 1));
3608 case R_ALPHA_BRADDR:
3610 /* The regular PC-relative stuff measures from the start of
3611 the instruction rather than the end. */
3615 case R_ALPHA_REFLONG:
3616 case R_ALPHA_REFQUAD:
3618 Elf_Internal_Rela outrel;
3621 /* Careful here to remember RELATIVE relocations for global
3622 variables for symbolic shared objects. */
3624 if (h && alpha_elf_dynamic_symbol_p (&h->root, info))
3626 BFD_ASSERT(h->root.dynindx != -1);
3627 outrel.r_info = ELF64_R_INFO(h->root.dynindx, r_type);
3628 outrel.r_addend = addend;
3629 addend = 0, relocation = 0;
3631 else if (info->shared && (input_section->flags & SEC_ALLOC))
3633 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3634 outrel.r_addend = 0;
3643 name = (bfd_elf_string_from_elf_section
3644 (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
3645 elf_section_data(input_section)->rel_hdr.sh_name));
3646 BFD_ASSERT(name != NULL);
3648 srel = bfd_get_section_by_name (dynobj, name);
3649 BFD_ASSERT(srel != NULL);
3654 if (elf_section_data (input_section)->stab_info == NULL)
3655 outrel.r_offset = rel->r_offset;
3660 off = (_bfd_stab_section_offset
3661 (output_bfd, &elf_hash_table (info)->stab_info,
3663 &elf_section_data (input_section)->stab_info,
3665 if (off == (bfd_vma) -1)
3667 outrel.r_offset = off;
3671 outrel.r_offset += (input_section->output_section->vma
3672 + input_section->output_offset);
3674 memset (&outrel, 0, sizeof outrel);
3676 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3677 ((Elf64_External_Rela *)
3679 + srel->reloc_count++);
3680 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3681 <= srel->_cooked_size);
3687 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3688 contents, rel->r_offset, relocation,
3698 case bfd_reloc_overflow:
3703 name = h->root.root.root.string;
3706 name = (bfd_elf_string_from_elf_section
3707 (input_bfd, symtab_hdr->sh_link, sym->st_name));
3711 name = bfd_section_name (input_bfd, sec);
3713 if (! ((*info->callbacks->reloc_overflow)
3714 (info, name, howto->name, (bfd_vma) 0,
3715 input_bfd, input_section, rel->r_offset)))
3721 case bfd_reloc_outofrange:
3729 /* Finish up dynamic symbol handling. We set the contents of various
3730 dynamic sections here. */
3733 elf64_alpha_finish_dynamic_symbol (output_bfd, info, h, sym)
3735 struct bfd_link_info *info;
3736 struct elf_link_hash_entry *h;
3737 Elf_Internal_Sym *sym;
3739 bfd *dynobj = elf_hash_table(info)->dynobj;
3741 if (h->plt.offset != MINUS_ONE)
3743 /* Fill in the .plt entry for this symbol. */
3744 asection *splt, *sgot, *srel;
3745 Elf_Internal_Rela outrel;
3746 bfd_vma got_addr, plt_addr;
3748 struct alpha_elf_got_entry *gotent;
3750 BFD_ASSERT (h->dynindx != -1);
3752 /* The first .got entry will be updated by the .plt with the
3753 address of the target function. */
3754 gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3755 BFD_ASSERT (gotent && gotent->addend == 0);
3757 splt = bfd_get_section_by_name (dynobj, ".plt");
3758 BFD_ASSERT (splt != NULL);
3759 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
3760 BFD_ASSERT (srel != NULL);
3761 sgot = alpha_elf_tdata (gotent->gotobj)->got;
3762 BFD_ASSERT (sgot != NULL);
3764 got_addr = (sgot->output_section->vma
3765 + sgot->output_offset
3766 + gotent->got_offset);
3767 plt_addr = (splt->output_section->vma
3768 + splt->output_offset
3771 plt_index = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
3773 /* Fill in the entry in the procedure linkage table. */
3775 unsigned insn1, insn2, insn3;
3777 insn1 = PLT_ENTRY_WORD1 | ((-(h->plt.offset + 4) >> 2) & 0x1fffff);
3778 insn2 = PLT_ENTRY_WORD2;
3779 insn3 = PLT_ENTRY_WORD3;
3781 bfd_put_32 (output_bfd, insn1, splt->contents + h->plt.offset);
3782 bfd_put_32 (output_bfd, insn2, splt->contents + h->plt.offset + 4);
3783 bfd_put_32 (output_bfd, insn3, splt->contents + h->plt.offset + 8);
3786 /* Fill in the entry in the .rela.plt section. */
3787 outrel.r_offset = got_addr;
3788 outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
3789 outrel.r_addend = 0;
3791 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3792 ((Elf64_External_Rela *)srel->contents
3795 if (!(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3797 /* Mark the symbol as undefined, rather than as defined in the
3798 .plt section. Leave the value alone. */
3799 sym->st_shndx = SHN_UNDEF;
3802 /* Fill in the entries in the .got. */
3803 bfd_put_64 (output_bfd, plt_addr, sgot->contents + gotent->got_offset);
3805 /* Subsequent .got entries will continue to bounce through the .plt. */
3808 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3809 BFD_ASSERT (! info->shared || srel != NULL);
3811 gotent = gotent->next;
3814 sgot = alpha_elf_tdata(gotent->gotobj)->got;
3815 BFD_ASSERT(sgot != NULL);
3816 BFD_ASSERT(gotent->addend == 0);
3818 bfd_put_64 (output_bfd, plt_addr,
3819 sgot->contents + gotent->got_offset);
3823 outrel.r_offset = (sgot->output_section->vma
3824 + sgot->output_offset
3825 + gotent->got_offset);
3826 outrel.r_info = ELF64_R_INFO(0, R_ALPHA_RELATIVE);
3827 outrel.r_addend = 0;
3829 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3830 ((Elf64_External_Rela *)
3832 + srel->reloc_count++);
3833 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3834 <= srel->_cooked_size);
3837 gotent = gotent->next;
3839 while (gotent != NULL);
3842 else if (alpha_elf_dynamic_symbol_p (h, info))
3844 /* Fill in the dynamic relocations for this symbol's .got entries. */
3846 Elf_Internal_Rela outrel;
3847 struct alpha_elf_got_entry *gotent;
3849 srel = bfd_get_section_by_name (dynobj, ".rela.got");
3850 BFD_ASSERT (srel != NULL);
3852 outrel.r_info = ELF64_R_INFO (h->dynindx, R_ALPHA_GLOB_DAT);
3853 for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
3855 gotent = gotent->next)
3857 asection *sgot = alpha_elf_tdata (gotent->gotobj)->got;
3858 outrel.r_offset = (sgot->output_section->vma
3859 + sgot->output_offset
3860 + gotent->got_offset);
3861 outrel.r_addend = gotent->addend;
3863 bfd_elf64_swap_reloca_out (output_bfd, &outrel,
3864 ((Elf64_External_Rela *)srel->contents
3865 + srel->reloc_count++));
3866 BFD_ASSERT (sizeof(Elf64_External_Rela) * srel->reloc_count
3867 <= srel->_cooked_size);
3871 /* Mark some specially defined symbols as absolute. */
3872 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3873 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3874 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3875 sym->st_shndx = SHN_ABS;
3880 /* Finish up the dynamic sections. */
3883 elf64_alpha_finish_dynamic_sections (output_bfd, info)
3885 struct bfd_link_info *info;
3890 dynobj = elf_hash_table (info)->dynobj;
3891 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3893 if (elf_hash_table (info)->dynamic_sections_created)
3896 Elf64_External_Dyn *dyncon, *dynconend;
3898 splt = bfd_get_section_by_name (dynobj, ".plt");
3899 BFD_ASSERT (splt != NULL && sdyn != NULL);
3901 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3902 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3903 for (; dyncon < dynconend; dyncon++)
3905 Elf_Internal_Dyn dyn;
3909 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3924 /* My interpretation of the TIS v1.1 ELF document indicates
3925 that RELASZ should not include JMPREL. This is not what
3926 the rest of the BFD does. It is, however, what the
3927 glibc ld.so wants. Do this fixup here until we found
3928 out who is right. */
3929 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
3933 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3938 s = bfd_get_section_by_name (output_bfd, name);
3939 dyn.d_un.d_ptr = (s ? s->vma : 0);
3943 s = bfd_get_section_by_name (output_bfd, name);
3945 (s->_cooked_size ? s->_cooked_size : s->_raw_size);
3949 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3952 /* Initialize the PLT0 entry */
3953 if (splt->_raw_size > 0)
3955 bfd_put_32 (output_bfd, PLT_HEADER_WORD1, splt->contents);
3956 bfd_put_32 (output_bfd, PLT_HEADER_WORD2, splt->contents + 4);
3957 bfd_put_32 (output_bfd, PLT_HEADER_WORD3, splt->contents + 8);
3958 bfd_put_32 (output_bfd, PLT_HEADER_WORD4, splt->contents + 12);
3960 /* The next two words will be filled in by ld.so */
3961 bfd_put_64 (output_bfd, 0, splt->contents + 16);
3962 bfd_put_64 (output_bfd, 0, splt->contents + 24);
3964 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3972 /* We need to use a special link routine to handle the .reginfo and
3973 the .mdebug sections. We need to merge all instances of these
3974 sections together, not write them all out sequentially. */
3977 elf64_alpha_final_link (abfd, info)
3979 struct bfd_link_info *info;
3982 struct bfd_link_order *p;
3983 asection *reginfo_sec, *mdebug_sec, *gptab_data_sec, *gptab_bss_sec;
3984 struct ecoff_debug_info debug;
3985 const struct ecoff_debug_swap *swap
3986 = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
3987 HDRR *symhdr = &debug.symbolic_header;
3988 PTR mdebug_handle = NULL;
3993 (*info->callbacks->warning)
3994 (info, _("using multiple gp values"), (char *) NULL,
3995 output_bfd, (asection *) NULL, (bfd_vma) 0);
3999 /* Go through the sections and collect the .reginfo and .mdebug
4003 gptab_data_sec = NULL;
4004 gptab_bss_sec = NULL;
4005 for (o = abfd->sections; o != (asection *) NULL; o = o->next)
4007 #ifdef ERIC_neverdef
4008 if (strcmp (o->name, ".reginfo") == 0)
4010 memset (®info, 0, sizeof reginfo);
4012 /* We have found the .reginfo section in the output file.
4013 Look through all the link_orders comprising it and merge
4014 the information together. */
4015 for (p = o->link_order_head;
4016 p != (struct bfd_link_order *) NULL;
4019 asection *input_section;
4021 Elf64_External_RegInfo ext;
4024 if (p->type != bfd_indirect_link_order)
4026 if (p->type == bfd_fill_link_order)
4031 input_section = p->u.indirect.section;
4032 input_bfd = input_section->owner;
4034 /* The linker emulation code has probably clobbered the
4035 size to be zero bytes. */
4036 if (input_section->_raw_size == 0)
4037 input_section->_raw_size = sizeof (Elf64_External_RegInfo);
4039 if (! bfd_get_section_contents (input_bfd, input_section,
4045 bfd_alpha_elf64_swap_reginfo_in (input_bfd, &ext, &sub);
4047 reginfo.ri_gprmask |= sub.ri_gprmask;
4048 reginfo.ri_cprmask[0] |= sub.ri_cprmask[0];
4049 reginfo.ri_cprmask[1] |= sub.ri_cprmask[1];
4050 reginfo.ri_cprmask[2] |= sub.ri_cprmask[2];
4051 reginfo.ri_cprmask[3] |= sub.ri_cprmask[3];
4053 /* ri_gp_value is set by the function
4054 alpha_elf_section_processing when the section is
4055 finally written out. */
4057 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4058 elf_link_input_bfd ignores this section. */
4059 input_section->flags &=~ SEC_HAS_CONTENTS;
4062 /* Force the section size to the value we want. */
4063 o->_raw_size = sizeof (Elf64_External_RegInfo);
4065 /* Skip this section later on (I don't think this currently
4066 matters, but someday it might). */
4067 o->link_order_head = (struct bfd_link_order *) NULL;
4073 if (strcmp (o->name, ".mdebug") == 0)
4075 struct extsym_info einfo;
4077 /* We have found the .mdebug section in the output file.
4078 Look through all the link_orders comprising it and merge
4079 the information together. */
4080 symhdr->magic = swap->sym_magic;
4081 /* FIXME: What should the version stamp be? */
4083 symhdr->ilineMax = 0;
4087 symhdr->isymMax = 0;
4088 symhdr->ioptMax = 0;
4089 symhdr->iauxMax = 0;
4091 symhdr->issExtMax = 0;
4094 symhdr->iextMax = 0;
4096 /* We accumulate the debugging information itself in the
4097 debug_info structure. */
4099 debug.external_dnr = NULL;
4100 debug.external_pdr = NULL;
4101 debug.external_sym = NULL;
4102 debug.external_opt = NULL;
4103 debug.external_aux = NULL;
4105 debug.ssext = debug.ssext_end = NULL;
4106 debug.external_fdr = NULL;
4107 debug.external_rfd = NULL;
4108 debug.external_ext = debug.external_ext_end = NULL;
4110 mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
4111 if (mdebug_handle == (PTR) NULL)
4120 static const char * const name[] =
4122 ".text", ".init", ".fini", ".data",
4123 ".rodata", ".sdata", ".sbss", ".bss"
4125 static const int sc[] = { scText, scInit, scFini, scData,
4126 scRData, scSData, scSBss, scBss };
4129 esym.cobol_main = 0;
4133 esym.asym.iss = issNil;
4134 esym.asym.st = stLocal;
4135 esym.asym.reserved = 0;
4136 esym.asym.index = indexNil;
4137 for (i = 0; i < 8; i++)
4139 esym.asym.sc = sc[i];
4140 s = bfd_get_section_by_name (abfd, name[i]);
4143 esym.asym.value = s->vma;
4144 last = s->vma + s->_raw_size;
4147 esym.asym.value = last;
4149 if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
4155 for (p = o->link_order_head;
4156 p != (struct bfd_link_order *) NULL;
4159 asection *input_section;
4161 const struct ecoff_debug_swap *input_swap;
4162 struct ecoff_debug_info input_debug;
4166 if (p->type != bfd_indirect_link_order)
4168 if (p->type == bfd_fill_link_order)
4173 input_section = p->u.indirect.section;
4174 input_bfd = input_section->owner;
4176 if (bfd_get_flavour (input_bfd) != bfd_target_elf_flavour
4177 || (get_elf_backend_data (input_bfd)
4178 ->elf_backend_ecoff_debug_swap) == NULL)
4180 /* I don't know what a non ALPHA ELF bfd would be
4181 doing with a .mdebug section, but I don't really
4182 want to deal with it. */
4186 input_swap = (get_elf_backend_data (input_bfd)
4187 ->elf_backend_ecoff_debug_swap);
4189 BFD_ASSERT (p->size == input_section->_raw_size);
4191 /* The ECOFF linking code expects that we have already
4192 read in the debugging information and set up an
4193 ecoff_debug_info structure, so we do that now. */
4194 if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
4198 if (! (bfd_ecoff_debug_accumulate
4199 (mdebug_handle, abfd, &debug, swap, input_bfd,
4200 &input_debug, input_swap, info)))
4203 /* Loop through the external symbols. For each one with
4204 interesting information, try to find the symbol in
4205 the linker global hash table and save the information
4206 for the output external symbols. */
4207 eraw_src = input_debug.external_ext;
4208 eraw_end = (eraw_src
4209 + (input_debug.symbolic_header.iextMax
4210 * input_swap->external_ext_size));
4212 eraw_src < eraw_end;
4213 eraw_src += input_swap->external_ext_size)
4217 struct alpha_elf_link_hash_entry *h;
4219 (*input_swap->swap_ext_in) (input_bfd, (PTR) eraw_src, &ext);
4220 if (ext.asym.sc == scNil
4221 || ext.asym.sc == scUndefined
4222 || ext.asym.sc == scSUndefined)
4225 name = input_debug.ssext + ext.asym.iss;
4226 h = alpha_elf_link_hash_lookup (alpha_elf_hash_table (info),
4227 name, false, false, true);
4228 if (h == NULL || h->esym.ifd != -2)
4234 < input_debug.symbolic_header.ifdMax);
4235 ext.ifd = input_debug.ifdmap[ext.ifd];
4241 /* Free up the information we just read. */
4242 free (input_debug.line);
4243 free (input_debug.external_dnr);
4244 free (input_debug.external_pdr);
4245 free (input_debug.external_sym);
4246 free (input_debug.external_opt);
4247 free (input_debug.external_aux);
4248 free (input_debug.ss);
4249 free (input_debug.ssext);
4250 free (input_debug.external_fdr);
4251 free (input_debug.external_rfd);
4252 free (input_debug.external_ext);
4254 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4255 elf_link_input_bfd ignores this section. */
4256 input_section->flags &=~ SEC_HAS_CONTENTS;
4259 #ifdef ERIC_neverdef
4262 /* Create .rtproc section. */
4263 rtproc_sec = bfd_get_section_by_name (abfd, ".rtproc");
4264 if (rtproc_sec == NULL)
4266 flagword flags = (SEC_HAS_CONTENTS
4268 | SEC_LINKER_CREATED
4271 rtproc_sec = bfd_make_section (abfd, ".rtproc");
4272 if (rtproc_sec == NULL
4273 || ! bfd_set_section_flags (abfd, rtproc_sec, flags)
4274 || ! bfd_set_section_alignment (abfd, rtproc_sec, 12))
4278 if (! alpha_elf_create_procedure_table (mdebug_handle, abfd,
4279 info, rtproc_sec, &debug))
4285 /* Build the external symbol information. */
4288 einfo.debug = &debug;
4290 einfo.failed = false;
4291 elf_link_hash_traverse (elf_hash_table (info),
4292 elf64_alpha_output_extsym,
4297 /* Set the size of the .mdebug section. */
4298 o->_raw_size = bfd_ecoff_debug_size (abfd, &debug, swap);
4300 /* Skip this section later on (I don't think this currently
4301 matters, but someday it might). */
4302 o->link_order_head = (struct bfd_link_order *) NULL;
4307 #ifdef ERIC_neverdef
4308 if (strncmp (o->name, ".gptab.", sizeof ".gptab." - 1) == 0)
4310 const char *subname;
4313 Elf64_External_gptab *ext_tab;
4316 /* The .gptab.sdata and .gptab.sbss sections hold
4317 information describing how the small data area would
4318 change depending upon the -G switch. These sections
4319 not used in executables files. */
4320 if (! info->relocateable)
4324 for (p = o->link_order_head;
4325 p != (struct bfd_link_order *) NULL;
4328 asection *input_section;
4330 if (p->type != bfd_indirect_link_order)
4332 if (p->type == bfd_fill_link_order)
4337 input_section = p->u.indirect.section;
4339 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4340 elf_link_input_bfd ignores this section. */
4341 input_section->flags &=~ SEC_HAS_CONTENTS;
4344 /* Skip this section later on (I don't think this
4345 currently matters, but someday it might). */
4346 o->link_order_head = (struct bfd_link_order *) NULL;
4348 /* Really remove the section. */
4349 for (secpp = &abfd->sections;
4351 secpp = &(*secpp)->next)
4353 *secpp = (*secpp)->next;
4354 --abfd->section_count;
4359 /* There is one gptab for initialized data, and one for
4360 uninitialized data. */
4361 if (strcmp (o->name, ".gptab.sdata") == 0)
4363 else if (strcmp (o->name, ".gptab.sbss") == 0)
4367 (*_bfd_error_handler)
4368 (_("%s: illegal section name `%s'"),
4369 bfd_get_filename (abfd), o->name);
4370 bfd_set_error (bfd_error_nonrepresentable_section);
4374 /* The linker script always combines .gptab.data and
4375 .gptab.sdata into .gptab.sdata, and likewise for
4376 .gptab.bss and .gptab.sbss. It is possible that there is
4377 no .sdata or .sbss section in the output file, in which
4378 case we must change the name of the output section. */
4379 subname = o->name + sizeof ".gptab" - 1;
4380 if (bfd_get_section_by_name (abfd, subname) == NULL)
4382 if (o == gptab_data_sec)
4383 o->name = ".gptab.data";
4385 o->name = ".gptab.bss";
4386 subname = o->name + sizeof ".gptab" - 1;
4387 BFD_ASSERT (bfd_get_section_by_name (abfd, subname) != NULL);
4390 /* Set up the first entry. */
4392 tab = (Elf64_gptab *) bfd_malloc (c * sizeof (Elf64_gptab));
4395 tab[0].gt_header.gt_current_g_value = elf_gp_size (abfd);
4396 tab[0].gt_header.gt_unused = 0;
4398 /* Combine the input sections. */
4399 for (p = o->link_order_head;
4400 p != (struct bfd_link_order *) NULL;
4403 asection *input_section;
4407 bfd_size_type gpentry;
4409 if (p->type != bfd_indirect_link_order)
4411 if (p->type == bfd_fill_link_order)
4416 input_section = p->u.indirect.section;
4417 input_bfd = input_section->owner;
4419 /* Combine the gptab entries for this input section one
4420 by one. We know that the input gptab entries are
4421 sorted by ascending -G value. */
4422 size = bfd_section_size (input_bfd, input_section);
4424 for (gpentry = sizeof (Elf64_External_gptab);
4426 gpentry += sizeof (Elf64_External_gptab))
4428 Elf64_External_gptab ext_gptab;
4429 Elf64_gptab int_gptab;
4435 if (! (bfd_get_section_contents
4436 (input_bfd, input_section, (PTR) &ext_gptab,
4437 gpentry, sizeof (Elf64_External_gptab))))
4443 bfd_alpha_elf64_swap_gptab_in (input_bfd, &ext_gptab,
4445 val = int_gptab.gt_entry.gt_g_value;
4446 add = int_gptab.gt_entry.gt_bytes - last;
4449 for (look = 1; look < c; look++)
4451 if (tab[look].gt_entry.gt_g_value >= val)
4452 tab[look].gt_entry.gt_bytes += add;
4454 if (tab[look].gt_entry.gt_g_value == val)
4460 Elf64_gptab *new_tab;
4463 /* We need a new table entry. */
4464 new_tab = ((Elf64_gptab *)
4465 bfd_realloc ((PTR) tab,
4466 (c + 1) * sizeof (Elf64_gptab)));
4467 if (new_tab == NULL)
4473 tab[c].gt_entry.gt_g_value = val;
4474 tab[c].gt_entry.gt_bytes = add;
4476 /* Merge in the size for the next smallest -G
4477 value, since that will be implied by this new
4480 for (look = 1; look < c; look++)
4482 if (tab[look].gt_entry.gt_g_value < val
4484 || (tab[look].gt_entry.gt_g_value
4485 > tab[max].gt_entry.gt_g_value)))
4489 tab[c].gt_entry.gt_bytes +=
4490 tab[max].gt_entry.gt_bytes;
4495 last = int_gptab.gt_entry.gt_bytes;
4498 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4499 elf_link_input_bfd ignores this section. */
4500 input_section->flags &=~ SEC_HAS_CONTENTS;
4503 /* The table must be sorted by -G value. */
4505 qsort (tab + 1, c - 1, sizeof (tab[0]), gptab_compare);
4507 /* Swap out the table. */
4508 ext_tab = ((Elf64_External_gptab *)
4509 bfd_alloc (abfd, c * sizeof (Elf64_External_gptab)));
4510 if (ext_tab == NULL)
4516 for (i = 0; i < c; i++)
4517 bfd_alpha_elf64_swap_gptab_out (abfd, tab + i, ext_tab + i);
4520 o->_raw_size = c * sizeof (Elf64_External_gptab);
4521 o->contents = (bfd_byte *) ext_tab;
4523 /* Skip this section later on (I don't think this currently
4524 matters, but someday it might). */
4525 o->link_order_head = (struct bfd_link_order *) NULL;
4531 /* Invoke the regular ELF backend linker to do all the work. */
4532 if (! bfd_elf64_bfd_final_link (abfd, info))
4535 /* Now write out the computed sections. */
4537 /* The .got subsections... */
4539 bfd *i, *dynobj = elf_hash_table(info)->dynobj;
4540 for (i = alpha_elf_hash_table(info)->got_list;
4542 i = alpha_elf_tdata(i)->got_link_next)
4546 /* elf_bfd_final_link already did everything in dynobj. */
4550 sgot = alpha_elf_tdata(i)->got;
4551 if (! bfd_set_section_contents (abfd, sgot->output_section,
4552 sgot->contents, sgot->output_offset,
4558 #ifdef ERIC_neverdef
4559 if (reginfo_sec != (asection *) NULL)
4561 Elf64_External_RegInfo ext;
4563 bfd_alpha_elf64_swap_reginfo_out (abfd, ®info, &ext);
4564 if (! bfd_set_section_contents (abfd, reginfo_sec, (PTR) &ext,
4565 (file_ptr) 0, sizeof ext))
4570 if (mdebug_sec != (asection *) NULL)
4572 BFD_ASSERT (abfd->output_has_begun);
4573 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
4575 mdebug_sec->filepos))
4578 bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
4581 if (gptab_data_sec != (asection *) NULL)
4583 if (! bfd_set_section_contents (abfd, gptab_data_sec,
4584 gptab_data_sec->contents,
4586 gptab_data_sec->_raw_size))
4590 if (gptab_bss_sec != (asection *) NULL)
4592 if (! bfd_set_section_contents (abfd, gptab_bss_sec,
4593 gptab_bss_sec->contents,
4595 gptab_bss_sec->_raw_size))
4602 /* ECOFF swapping routines. These are used when dealing with the
4603 .mdebug section, which is in the ECOFF debugging format. Copied
4604 from elf32-mips.c. */
4605 static const struct ecoff_debug_swap
4606 elf64_alpha_ecoff_debug_swap =
4608 /* Symbol table magic number. */
4610 /* Alignment of debugging information. E.g., 4. */
4612 /* Sizes of external symbolic information. */
4613 sizeof (struct hdr_ext),
4614 sizeof (struct dnr_ext),
4615 sizeof (struct pdr_ext),
4616 sizeof (struct sym_ext),
4617 sizeof (struct opt_ext),
4618 sizeof (struct fdr_ext),
4619 sizeof (struct rfd_ext),
4620 sizeof (struct ext_ext),
4621 /* Functions to swap in external symbolic data. */
4630 _bfd_ecoff_swap_tir_in,
4631 _bfd_ecoff_swap_rndx_in,
4632 /* Functions to swap out external symbolic data. */
4641 _bfd_ecoff_swap_tir_out,
4642 _bfd_ecoff_swap_rndx_out,
4643 /* Function to read in symbolic data. */
4644 elf64_alpha_read_ecoff_info
4647 /* Use a non-standard hash bucket size of 8. */
4649 const struct elf_size_info alpha_elf_size_info =
4651 sizeof (Elf64_External_Ehdr),
4652 sizeof (Elf64_External_Phdr),
4653 sizeof (Elf64_External_Shdr),
4654 sizeof (Elf64_External_Rel),
4655 sizeof (Elf64_External_Rela),
4656 sizeof (Elf64_External_Sym),
4657 sizeof (Elf64_External_Dyn),
4658 sizeof (Elf_External_Note),
4662 ELFCLASS64, EV_CURRENT,
4663 bfd_elf64_write_out_phdrs,
4664 bfd_elf64_write_shdrs_and_ehdr,
4665 bfd_elf64_write_relocs,
4666 bfd_elf64_swap_symbol_out,
4667 bfd_elf64_slurp_reloc_table,
4668 bfd_elf64_slurp_symbol_table,
4669 bfd_elf64_swap_dyn_in,
4670 bfd_elf64_swap_dyn_out,
4677 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4678 #define TARGET_LITTLE_NAME "elf64-alpha"
4679 #define ELF_ARCH bfd_arch_alpha
4680 #define ELF_MACHINE_CODE EM_ALPHA
4681 #define ELF_MAXPAGESIZE 0x10000
4683 #define bfd_elf64_bfd_link_hash_table_create \
4684 elf64_alpha_bfd_link_hash_table_create
4686 #define bfd_elf64_bfd_reloc_type_lookup \
4687 elf64_alpha_bfd_reloc_type_lookup
4688 #define elf_info_to_howto \
4689 elf64_alpha_info_to_howto
4691 #define bfd_elf64_mkobject \
4692 elf64_alpha_mkobject
4693 #define elf_backend_object_p \
4694 elf64_alpha_object_p
4696 #define elf_backend_section_from_shdr \
4697 elf64_alpha_section_from_shdr
4698 #define elf_backend_fake_sections \
4699 elf64_alpha_fake_sections
4701 #define bfd_elf64_bfd_is_local_label_name \
4702 elf64_alpha_is_local_label_name
4703 #define bfd_elf64_find_nearest_line \
4704 elf64_alpha_find_nearest_line
4705 #define bfd_elf64_bfd_relax_section \
4706 elf64_alpha_relax_section
4708 #define elf_backend_add_symbol_hook \
4709 elf64_alpha_add_symbol_hook
4710 #define elf_backend_check_relocs \
4711 elf64_alpha_check_relocs
4712 #define elf_backend_create_dynamic_sections \
4713 elf64_alpha_create_dynamic_sections
4714 #define elf_backend_adjust_dynamic_symbol \
4715 elf64_alpha_adjust_dynamic_symbol
4716 #define elf_backend_always_size_sections \
4717 elf64_alpha_always_size_sections
4718 #define elf_backend_size_dynamic_sections \
4719 elf64_alpha_size_dynamic_sections
4720 #define elf_backend_relocate_section \
4721 elf64_alpha_relocate_section
4722 #define elf_backend_finish_dynamic_symbol \
4723 elf64_alpha_finish_dynamic_symbol
4724 #define elf_backend_finish_dynamic_sections \
4725 elf64_alpha_finish_dynamic_sections
4726 #define bfd_elf64_bfd_final_link \
4727 elf64_alpha_final_link
4729 #define elf_backend_ecoff_debug_swap \
4730 &elf64_alpha_ecoff_debug_swap
4732 #define elf_backend_size_info \
4736 * A few constants that determine how the .plt section is set up.
4738 #define elf_backend_want_got_plt 0
4739 #define elf_backend_plt_readonly 0
4740 #define elf_backend_want_plt_sym 1
4741 #define elf_backend_got_header_size 0
4742 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4744 #include "elf64-target.h"