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));
133 struct alpha_elf_link_hash_entry
135 struct elf_link_hash_entry root
;
137 /* External symbol information. */
140 /* Cumulative flags for all the .got entries. */
143 /* Contexts (LITUSE) in which a literal was referenced. */
144 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
145 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
146 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
147 #define ALPHA_ELF_LINK_HASH_LU_FUNC 0x08
149 /* Used to implement multiple .got subsections. */
150 struct alpha_elf_got_entry
152 struct alpha_elf_got_entry
*next
;
154 /* which .got subsection? */
157 /* the addend in effect for this entry. */
160 /* the .got offset for this entry. */
165 /* An additional flag. */
166 #define ALPHA_ELF_GOT_ENTRY_RELOCS_DONE 0x10
171 /* used to count non-got, non-plt relocations for delayed sizing
172 of relocation sections. */
173 struct alpha_elf_reloc_entry
175 struct alpha_elf_reloc_entry
*next
;
177 /* which .reloc section? */
180 /* what kind of relocation? */
183 /* how many did we find? */
188 /* Alpha ELF linker hash table. */
190 struct alpha_elf_link_hash_table
192 struct elf_link_hash_table root
;
194 /* The head of a list of .got subsections linked through
195 alpha_elf_tdata(abfd)->got_link_next. */
199 /* Look up an entry in a Alpha ELF linker hash table. */
201 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
202 ((struct alpha_elf_link_hash_entry *) \
203 elf_link_hash_lookup (&(table)->root, (string), (create), \
206 /* Traverse a Alpha ELF linker hash table. */
208 #define alpha_elf_link_hash_traverse(table, func, info) \
209 (elf_link_hash_traverse \
211 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
214 /* Get the Alpha ELF linker hash table from a link_info structure. */
216 #define alpha_elf_hash_table(p) \
217 ((struct alpha_elf_link_hash_table *) ((p)->hash))
219 /* Get the object's symbols as our own entry type. */
221 #define alpha_elf_sym_hashes(abfd) \
222 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
224 /* Should we do dynamic things to this symbol? */
226 #define alpha_elf_dynamic_symbol_p(h, info) \
227 ((((info)->shared && !(info)->symbolic) \
228 || (((h)->elf_link_hash_flags \
229 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)) \
230 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)) \
231 || (h)->root.type == bfd_link_hash_undefweak \
232 || (h)->root.type == bfd_link_hash_defweak) \
233 && (h)->dynindx != -1)
235 /* Create an entry in a Alpha ELF linker hash table. */
237 static struct bfd_hash_entry
*
238 elf64_alpha_link_hash_newfunc (entry
, table
, string
)
239 struct bfd_hash_entry
*entry
;
240 struct bfd_hash_table
*table
;
243 struct alpha_elf_link_hash_entry
*ret
=
244 (struct alpha_elf_link_hash_entry
*) entry
;
246 /* Allocate the structure if it has not already been allocated by a
248 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
249 ret
= ((struct alpha_elf_link_hash_entry
*)
250 bfd_hash_allocate (table
,
251 sizeof (struct alpha_elf_link_hash_entry
)));
252 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
253 return (struct bfd_hash_entry
*) ret
;
255 /* Call the allocation method of the superclass. */
256 ret
= ((struct alpha_elf_link_hash_entry
*)
257 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
259 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
261 /* Set local fields. */
262 memset (&ret
->esym
, 0, sizeof (EXTR
));
263 /* We use -2 as a marker to indicate that the information has
264 not been set. -1 means there is no associated ifd. */
267 ret
->got_entries
= NULL
;
268 ret
->reloc_entries
= NULL
;
271 return (struct bfd_hash_entry
*) ret
;
274 /* Create a Alpha ELF linker hash table. */
276 static struct bfd_link_hash_table
*
277 elf64_alpha_bfd_link_hash_table_create (abfd
)
280 struct alpha_elf_link_hash_table
*ret
;
282 ret
= ((struct alpha_elf_link_hash_table
*)
283 bfd_zalloc (abfd
, sizeof (struct alpha_elf_link_hash_table
)));
284 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
287 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
288 elf64_alpha_link_hash_newfunc
))
290 bfd_release (abfd
, ret
);
294 return &ret
->root
.root
;
297 /* We have some private fields hanging off of the elf_tdata structure. */
299 struct alpha_elf_obj_tdata
301 struct elf_obj_tdata root
;
303 /* For every input file, these are the got entries for that object's
305 struct alpha_elf_got_entry
** local_got_entries
;
307 /* For every input file, this is the object that owns the got that
308 this input file uses. */
311 /* For every got, this is a linked list through the objects using this got */
312 bfd
*in_got_link_next
;
314 /* For every got, this is a link to the next got subsegment. */
317 /* For every got, this is the section. */
320 /* For every got, this is it's total number of *entries*. */
321 int total_got_entries
;
323 /* For every got, this is the sum of the number of *entries* required
324 to hold all of the member object's local got. */
325 int n_local_got_entries
;
328 #define alpha_elf_tdata(abfd) \
329 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
332 elf64_alpha_mkobject (abfd
)
335 abfd
->tdata
.any
= bfd_zalloc (abfd
, sizeof (struct alpha_elf_obj_tdata
));
336 if (abfd
->tdata
.any
== NULL
)
342 elf64_alpha_object_p (abfd
)
345 /* Allocate our special target data. */
346 struct alpha_elf_obj_tdata
*new_tdata
;
347 new_tdata
= bfd_zalloc (abfd
, sizeof (struct alpha_elf_obj_tdata
));
348 if (new_tdata
== NULL
)
350 new_tdata
->root
= *abfd
->tdata
.elf_obj_data
;
351 abfd
->tdata
.any
= new_tdata
;
353 /* Set the right machine number for an Alpha ELF file. */
354 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
357 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
358 from smaller values. Start with zero, widen, *then* decrement. */
359 #define MINUS_ONE (((bfd_vma)0) - 1)
361 static reloc_howto_type elf64_alpha_howto_table
[] =
363 HOWTO (R_ALPHA_NONE
, /* type */
365 0, /* size (0 = byte, 1 = short, 2 = long) */
367 true, /* pc_relative */
369 complain_overflow_dont
, /* complain_on_overflow */
370 elf64_alpha_reloc_nil
, /* special_function */
372 false, /* partial_inplace */
375 true), /* pcrel_offset */
377 /* A 32 bit reference to a symbol. */
378 HOWTO (R_ALPHA_REFLONG
, /* type */
380 2, /* size (0 = byte, 1 = short, 2 = long) */
382 false, /* pc_relative */
384 complain_overflow_bitfield
, /* complain_on_overflow */
385 0, /* special_function */
386 "REFLONG", /* name */
387 false, /* partial_inplace */
388 0xffffffff, /* src_mask */
389 0xffffffff, /* dst_mask */
390 false), /* pcrel_offset */
392 /* A 64 bit reference to a symbol. */
393 HOWTO (R_ALPHA_REFQUAD
, /* type */
395 4, /* size (0 = byte, 1 = short, 2 = long) */
397 false, /* pc_relative */
399 complain_overflow_bitfield
, /* complain_on_overflow */
400 0, /* special_function */
401 "REFQUAD", /* name */
402 false, /* partial_inplace */
403 MINUS_ONE
, /* src_mask */
404 MINUS_ONE
, /* dst_mask */
405 false), /* pcrel_offset */
407 /* A 32 bit GP relative offset. This is just like REFLONG except
408 that when the value is used the value of the gp register will be
410 HOWTO (R_ALPHA_GPREL32
, /* type */
412 2, /* size (0 = byte, 1 = short, 2 = long) */
414 false, /* pc_relative */
416 complain_overflow_bitfield
, /* complain_on_overflow */
417 0, /* special_function */
418 "GPREL32", /* name */
419 false, /* partial_inplace */
420 0xffffffff, /* src_mask */
421 0xffffffff, /* dst_mask */
422 false), /* pcrel_offset */
424 /* Used for an instruction that refers to memory off the GP register. */
425 HOWTO (R_ALPHA_LITERAL
, /* type */
427 2, /* size (0 = byte, 1 = short, 2 = long) */
429 false, /* pc_relative */
431 complain_overflow_signed
, /* complain_on_overflow */
432 0, /* special_function */
433 "ELF_LITERAL", /* name */
434 false, /* partial_inplace */
435 0xffff, /* src_mask */
436 0xffff, /* dst_mask */
437 false), /* pcrel_offset */
439 /* This reloc only appears immediately following an ELF_LITERAL reloc.
440 It identifies a use of the literal. The symbol index is special:
441 1 means the literal address is in the base register of a memory
442 format instruction; 2 means the literal address is in the byte
443 offset register of a byte-manipulation instruction; 3 means the
444 literal address is in the target register of a jsr instruction.
445 This does not actually do any relocation. */
446 HOWTO (R_ALPHA_LITUSE
, /* type */
448 2, /* size (0 = byte, 1 = short, 2 = long) */
450 false, /* pc_relative */
452 complain_overflow_dont
, /* complain_on_overflow */
453 elf64_alpha_reloc_nil
, /* special_function */
455 false, /* partial_inplace */
458 false), /* pcrel_offset */
460 /* Load the gp register. This is always used for a ldah instruction
461 which loads the upper 16 bits of the gp register. The symbol
462 index of the GPDISP instruction is an offset in bytes to the lda
463 instruction that loads the lower 16 bits. The value to use for
464 the relocation is the difference between the GP value and the
465 current location; the load will always be done against a register
466 holding the current address.
468 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
469 any offset is present in the instructions, it is an offset from
470 the register to the ldah instruction. This lets us avoid any
471 stupid hackery like inventing a gp value to do partial relocation
472 against. Also unlike ECOFF, we do the whole relocation off of
473 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
474 space consuming bit, that, since all the information was present
475 in the GPDISP_HI16 reloc. */
476 HOWTO (R_ALPHA_GPDISP
, /* type */
478 2, /* size (0 = byte, 1 = short, 2 = long) */
480 false, /* pc_relative */
482 complain_overflow_dont
, /* complain_on_overflow */
483 elf64_alpha_reloc_gpdisp
, /* special_function */
485 false, /* partial_inplace */
486 0xffff, /* src_mask */
487 0xffff, /* dst_mask */
488 true), /* pcrel_offset */
490 /* A 21 bit branch. */
491 HOWTO (R_ALPHA_BRADDR
, /* type */
493 2, /* size (0 = byte, 1 = short, 2 = long) */
495 true, /* pc_relative */
497 complain_overflow_signed
, /* complain_on_overflow */
498 0, /* special_function */
500 false, /* partial_inplace */
501 0x1fffff, /* src_mask */
502 0x1fffff, /* dst_mask */
503 true), /* pcrel_offset */
505 /* A hint for a jump to a register. */
506 HOWTO (R_ALPHA_HINT
, /* type */
508 2, /* size (0 = byte, 1 = short, 2 = long) */
510 true, /* pc_relative */
512 complain_overflow_dont
, /* complain_on_overflow */
513 0, /* special_function */
515 false, /* partial_inplace */
516 0x3fff, /* src_mask */
517 0x3fff, /* dst_mask */
518 true), /* pcrel_offset */
520 /* 16 bit PC relative offset. */
521 HOWTO (R_ALPHA_SREL16
, /* type */
523 1, /* size (0 = byte, 1 = short, 2 = long) */
525 true, /* pc_relative */
527 complain_overflow_signed
, /* complain_on_overflow */
528 0, /* special_function */
530 false, /* partial_inplace */
531 0xffff, /* src_mask */
532 0xffff, /* dst_mask */
533 false), /* pcrel_offset */
535 /* 32 bit PC relative offset. */
536 HOWTO (R_ALPHA_SREL32
, /* type */
538 2, /* size (0 = byte, 1 = short, 2 = long) */
540 true, /* pc_relative */
542 complain_overflow_signed
, /* complain_on_overflow */
543 0, /* special_function */
545 false, /* partial_inplace */
546 0xffffffff, /* src_mask */
547 0xffffffff, /* dst_mask */
548 false), /* pcrel_offset */
550 /* A 64 bit PC relative offset. */
551 HOWTO (R_ALPHA_SREL64
, /* type */
553 4, /* size (0 = byte, 1 = short, 2 = long) */
555 true, /* pc_relative */
557 complain_overflow_signed
, /* complain_on_overflow */
558 0, /* special_function */
560 false, /* partial_inplace */
561 MINUS_ONE
, /* src_mask */
562 MINUS_ONE
, /* dst_mask */
563 false), /* pcrel_offset */
565 /* Push a value on the reloc evaluation stack. */
566 /* Not implemented -- it's dumb. */
567 HOWTO (R_ALPHA_OP_PUSH
, /* type */
569 0, /* size (0 = byte, 1 = short, 2 = long) */
571 false, /* pc_relative */
573 complain_overflow_dont
, /* complain_on_overflow */
574 elf64_alpha_reloc_bad
, /* special_function */
575 "OP_PUSH", /* name */
576 false, /* partial_inplace */
579 false), /* pcrel_offset */
581 /* Store the value from the stack at the given address. Store it in
582 a bitfield of size r_size starting at bit position r_offset. */
583 /* Not implemented -- it's dumb. */
584 HOWTO (R_ALPHA_OP_STORE
, /* type */
586 4, /* size (0 = byte, 1 = short, 2 = long) */
588 false, /* pc_relative */
590 complain_overflow_dont
, /* complain_on_overflow */
591 elf64_alpha_reloc_bad
, /* special_function */
592 "OP_STORE", /* name */
593 false, /* partial_inplace */
595 MINUS_ONE
, /* dst_mask */
596 false), /* pcrel_offset */
598 /* Subtract the reloc address from the value on the top of the
600 /* Not implemented -- it's dumb. */
601 HOWTO (R_ALPHA_OP_PSUB
, /* type */
603 0, /* size (0 = byte, 1 = short, 2 = long) */
605 false, /* pc_relative */
607 complain_overflow_dont
, /* complain_on_overflow */
608 elf64_alpha_reloc_bad
, /* special_function */
609 "OP_PSUB", /* name */
610 false, /* partial_inplace */
613 false), /* pcrel_offset */
615 /* Shift the value on the top of the relocation stack right by the
617 /* Not implemented -- it's dumb. */
618 HOWTO (R_ALPHA_OP_PRSHIFT
, /* type */
620 0, /* size (0 = byte, 1 = short, 2 = long) */
622 false, /* pc_relative */
624 complain_overflow_dont
, /* complain_on_overflow */
625 elf64_alpha_reloc_bad
, /* special_function */
626 "OP_PRSHIFT", /* name */
627 false, /* partial_inplace */
630 false), /* pcrel_offset */
632 /* Change the value of GP used by +r_addend until the next GPVALUE or the
633 end of the input bfd. */
634 /* Not implemented -- it's dumb. */
635 HOWTO (R_ALPHA_GPVALUE
,
637 0, /* size (0 = byte, 1 = short, 2 = long) */
639 false, /* pc_relative */
641 complain_overflow_dont
, /* complain_on_overflow */
642 elf64_alpha_reloc_bad
, /* special_function */
643 "GPVALUE", /* name */
644 false, /* partial_inplace */
647 false), /* pcrel_offset */
649 /* The high 16 bits of the displacement from GP to the target. */
650 HOWTO (R_ALPHA_GPRELHIGH
,
652 2, /* size (0 = byte, 1 = short, 2 = long) */
654 false, /* pc_relative */
656 complain_overflow_signed
, /* complain_on_overflow */
657 elf64_alpha_reloc_bad
, /* special_function */
658 "GPRELHIGH", /* name */
659 false, /* partial_inplace */
660 0xffff, /* src_mask */
661 0xffff, /* dst_mask */
662 false), /* pcrel_offset */
664 /* The low 16 bits of the displacement from GP to the target. */
665 HOWTO (R_ALPHA_GPRELLOW
,
667 2, /* size (0 = byte, 1 = short, 2 = long) */
669 false, /* pc_relative */
671 complain_overflow_dont
, /* complain_on_overflow */
672 elf64_alpha_reloc_bad
, /* special_function */
673 "GPRELLOW", /* name */
674 false, /* partial_inplace */
675 0xffff, /* src_mask */
676 0xffff, /* dst_mask */
677 false), /* pcrel_offset */
679 /* A 16-bit displacement from the GP to the target. */
680 /* XXX: Not implemented. */
681 HOWTO (R_ALPHA_IMMED_GP_16
,
683 2, /* size (0 = byte, 1 = short, 2 = long) */
685 false, /* pc_relative */
687 complain_overflow_signed
, /* complain_on_overflow */
688 0, /* special_function */
689 "IMMED_GP_16", /* name */
690 false, /* partial_inplace */
691 0xffff, /* src_mask */
692 0xffff, /* dst_mask */
693 false), /* pcrel_offset */
695 /* The high bits of a 32-bit displacement from the GP to the target; the
696 low bits are supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
697 /* XXX: Not implemented. */
698 HOWTO (R_ALPHA_IMMED_GP_HI32
,
700 0, /* size (0 = byte, 1 = short, 2 = long) */
702 false, /* pc_relative */
704 complain_overflow_dont
, /* complain_on_overflow */
705 elf64_alpha_reloc_bad
, /* special_function */
706 "IMMED_GP_HI32", /* name */
707 false, /* partial_inplace */
710 false), /* pcrel_offset */
712 /* The high bits of a 32-bit displacement to the starting address of the
713 current section (the relocation target is ignored); the low bits are
714 supplied in the subsequent R_ALPHA_IMMED_LO32 relocs. */
715 /* XXX: Not implemented. */
716 HOWTO (R_ALPHA_IMMED_SCN_HI32
,
718 0, /* size (0 = byte, 1 = short, 2 = long) */
720 false, /* pc_relative */
722 complain_overflow_dont
, /* complain_on_overflow */
723 elf64_alpha_reloc_bad
, /* special_function */
724 "IMMED_SCN_HI32", /* name */
725 false, /* partial_inplace */
728 false), /* pcrel_offset */
730 /* The high bits of a 32-bit displacement from the previous br, bsr, jsr
731 or jmp insn (as tagged by a BRADDR or HINT reloc) to the target; the
732 low bits are supplied by subsequent R_ALPHA_IMMED_LO32 relocs. */
733 /* XXX: Not implemented. */
734 HOWTO (R_ALPHA_IMMED_BR_HI32
,
736 0, /* size (0 = byte, 1 = short, 2 = long) */
738 false, /* pc_relative */
740 complain_overflow_dont
, /* complain_on_overflow */
741 elf64_alpha_reloc_bad
, /* special_function */
742 "IMMED_BR_HI32", /* name */
743 false, /* partial_inplace */
746 false), /* pcrel_offset */
748 /* The low 16 bits of a displacement calculated in a previous HI32 reloc. */
749 /* XXX: Not implemented. */
750 HOWTO (R_ALPHA_IMMED_LO32
,
752 0, /* size (0 = byte, 1 = short, 2 = long) */
754 false, /* pc_relative */
756 complain_overflow_dont
, /* complain_on_overflow */
757 elf64_alpha_reloc_bad
, /* special_function */
758 "IMMED_LO32", /* name */
759 false, /* partial_inplace */
762 false), /* pcrel_offset */
764 /* Misc ELF relocations. */
766 /* A dynamic relocation to copy the target into our .dynbss section. */
767 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
768 is present because every other ELF has one, but should not be used
769 because .dynbss is an ugly thing. */
776 complain_overflow_dont
,
777 bfd_elf_generic_reloc
,
784 /* A dynamic relocation for a .got entry. */
785 HOWTO (R_ALPHA_GLOB_DAT
,
791 complain_overflow_dont
,
792 bfd_elf_generic_reloc
,
799 /* A dynamic relocation for a .plt entry. */
800 HOWTO (R_ALPHA_JMP_SLOT
,
806 complain_overflow_dont
,
807 bfd_elf_generic_reloc
,
814 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
815 HOWTO (R_ALPHA_RELATIVE
,
821 complain_overflow_dont
,
822 bfd_elf_generic_reloc
,
830 /* A relocation function which doesn't do anything. */
832 static bfd_reloc_status_type
833 elf64_alpha_reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
840 char **error_message
;
843 reloc
->address
+= sec
->output_offset
;
847 /* A relocation function used for an unsupported reloc. */
849 static bfd_reloc_status_type
850 elf64_alpha_reloc_bad (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
857 char **error_message
;
860 reloc
->address
+= sec
->output_offset
;
861 return bfd_reloc_notsupported
;
864 /* Do the work of the GPDISP relocation. */
866 static bfd_reloc_status_type
867 elf64_alpha_do_reloc_gpdisp (abfd
, gpdisp
, p_ldah
, p_lda
)
873 bfd_reloc_status_type ret
= bfd_reloc_ok
;
875 unsigned long i_ldah
, i_lda
;
877 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
878 i_lda
= bfd_get_32 (abfd
, p_lda
);
880 /* Complain if the instructions are not correct. */
881 if (((i_ldah
>> 26) & 0x3f) != 0x09
882 || ((i_lda
>> 26) & 0x3f) != 0x08)
883 ret
= bfd_reloc_dangerous
;
885 /* Extract the user-supplied offset, mirroring the sign extensions
886 that the instructions perform. */
887 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
888 addend
= (addend
^ 0x80008000) - 0x80008000;
892 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
893 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
894 ret
= bfd_reloc_overflow
;
896 /* compensate for the sign extension again. */
897 i_ldah
= ((i_ldah
& 0xffff0000)
898 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
899 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
901 bfd_put_32 (abfd
, i_ldah
, p_ldah
);
902 bfd_put_32 (abfd
, i_lda
, p_lda
);
907 /* The special function for the GPDISP reloc. */
909 static bfd_reloc_status_type
910 elf64_alpha_reloc_gpdisp (abfd
, reloc_entry
, sym
, data
, input_section
,
913 arelent
*reloc_entry
;
916 asection
*input_section
;
920 bfd_reloc_status_type ret
;
921 bfd_vma gp
, relocation
;
922 bfd_byte
*p_ldah
, *p_lda
;
924 /* Don't do anything if we're not doing a final link. */
927 reloc_entry
->address
+= input_section
->output_offset
;
931 if (reloc_entry
->address
> input_section
->_cooked_size
||
932 reloc_entry
->address
+ reloc_entry
->addend
> input_section
->_cooked_size
)
933 return bfd_reloc_outofrange
;
935 /* The gp used in the portion of the output object to which this
936 input object belongs is cached on the input bfd. */
937 gp
= _bfd_get_gp_value (abfd
);
939 relocation
= (input_section
->output_section
->vma
940 + input_section
->output_offset
941 + reloc_entry
->address
);
943 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
944 p_lda
= p_ldah
+ reloc_entry
->addend
;
946 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
948 /* Complain if the instructions are not correct. */
949 if (ret
== bfd_reloc_dangerous
)
950 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
955 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
959 bfd_reloc_code_real_type bfd_reloc_val
;
963 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
965 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
966 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
967 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
968 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
969 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
970 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
971 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
972 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
973 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
974 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
975 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
976 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
977 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
979 /* The BFD_RELOC_ALPHA_USER_* relocations are used by the assembler to process
980 the explicit !<reloc>!sequence relocations, and are mapped into the normal
981 relocations at the end of processing. */
982 {BFD_RELOC_ALPHA_USER_LITERAL
, R_ALPHA_LITERAL
},
983 {BFD_RELOC_ALPHA_USER_LITUSE_BASE
, R_ALPHA_LITUSE
},
984 {BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF
, R_ALPHA_LITUSE
},
985 {BFD_RELOC_ALPHA_USER_LITUSE_JSR
, R_ALPHA_LITUSE
},
986 {BFD_RELOC_ALPHA_USER_GPDISP
, R_ALPHA_GPDISP
},
987 {BFD_RELOC_ALPHA_USER_GPRELHIGH
, R_ALPHA_GPRELHIGH
},
988 {BFD_RELOC_ALPHA_USER_GPRELLOW
, R_ALPHA_GPRELLOW
},
991 /* Given a BFD reloc type, return a HOWTO structure. */
993 static reloc_howto_type
*
994 elf64_alpha_bfd_reloc_type_lookup (abfd
, code
)
996 bfd_reloc_code_real_type code
;
998 const struct elf_reloc_map
*i
, *e
;
999 i
= e
= elf64_alpha_reloc_map
;
1000 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1003 if (i
->bfd_reloc_val
== code
)
1004 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1009 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1012 elf64_alpha_info_to_howto (abfd
, cache_ptr
, dst
)
1015 Elf64_Internal_Rela
*dst
;
1019 r_type
= ELF64_R_TYPE(dst
->r_info
);
1020 BFD_ASSERT (r_type
< (unsigned int) R_ALPHA_max
);
1021 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1024 /* These functions do relaxation for Alpha ELF.
1026 Currently I'm only handling what I can do with existing compiler
1027 and assembler support, which means no instructions are removed,
1028 though some may be nopped. At this time GCC does not emit enough
1029 information to do all of the relaxing that is possible. It will
1030 take some not small amount of work for that to happen.
1032 There are a couple of interesting papers that I once read on this
1033 subject, that I cannot find references to at the moment, that
1034 related to Alpha in particular. They are by David Wall, then of
1038 #define OP_LDAH 0x09
1039 #define INSN_JSR 0x68004000
1040 #define INSN_JSR_MASK 0xfc00c000
1044 #define INSN_UNOP 0x2fe00000
1046 struct alpha_relax_info
1051 Elf_Internal_Rela
*relocs
, *relend
;
1052 struct bfd_link_info
*link_info
;
1053 boolean changed_contents
;
1054 boolean changed_relocs
;
1058 struct alpha_elf_link_hash_entry
*h
;
1059 struct alpha_elf_got_entry
*gotent
;
1060 unsigned char other
;
1063 static Elf_Internal_Rela
* elf64_alpha_relax_with_lituse
1064 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1065 Elf_Internal_Rela
*irel
, Elf_Internal_Rela
*irelend
));
1067 static boolean elf64_alpha_relax_without_lituse
1068 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
,
1069 Elf_Internal_Rela
*irel
));
1071 static bfd_vma elf64_alpha_relax_opt_call
1072 PARAMS((struct alpha_relax_info
*info
, bfd_vma symval
));
1074 static boolean elf64_alpha_relax_section
1075 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
1078 static Elf_Internal_Rela
*
1079 elf64_alpha_find_reloc_at_ofs (rel
, relend
, offset
, type
)
1080 Elf_Internal_Rela
*rel
, *relend
;
1084 while (rel
< relend
)
1086 if (rel
->r_offset
== offset
&& ELF64_R_TYPE (rel
->r_info
) == type
)
1093 static Elf_Internal_Rela
*
1094 elf64_alpha_relax_with_lituse (info
, symval
, irel
, irelend
)
1095 struct alpha_relax_info
*info
;
1097 Elf_Internal_Rela
*irel
, *irelend
;
1099 Elf_Internal_Rela
*urel
;
1100 int flags
, count
, i
;
1101 bfd_signed_vma disp
;
1104 boolean lit_reused
= false;
1105 boolean all_optimized
= true;
1106 unsigned int lit_insn
;
1108 lit_insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1109 if (lit_insn
>> 26 != OP_LDQ
)
1111 ((*_bfd_error_handler
)
1112 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1113 bfd_get_filename (info
->abfd
), info
->sec
->name
,
1114 (unsigned long)irel
->r_offset
));
1118 /* Summarize how this particular LITERAL is used. */
1119 for (urel
= irel
+1, flags
= count
= 0; urel
< irelend
; ++urel
, ++count
)
1121 if (ELF64_R_TYPE (urel
->r_info
) != R_ALPHA_LITUSE
)
1123 if (urel
->r_addend
>= 0 && urel
->r_addend
<= 3)
1124 flags
|= 1 << urel
->r_addend
;
1127 /* A little preparation for the loop... */
1128 disp
= symval
- info
->gp
;
1130 for (urel
= irel
+1, i
= 0; i
< count
; ++i
, ++urel
)
1134 bfd_signed_vma xdisp
;
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. */
1149 /* Extract the displacement from the instruction, sign-extending
1150 it if necessary, then test whether it is within 16 or 32 bits
1151 displacement from GP. */
1152 insn_disp
= insn
& 0x0000ffff;
1153 if (insn_disp
& 0x00008000)
1154 insn_disp
|= 0xffff0000; /* Negative: sign-extend. */
1156 xdisp
= disp
+ insn_disp
;
1157 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x00008000 && xdisp
< 0x00008000);
1158 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000 && xdisp
< 0x7fff8000);
1162 /* Take the op code and dest from this insn, take the base
1163 register from the literal insn. Leave the offset alone. */
1164 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
1165 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1167 urel
->r_addend
= irel
->r_addend
;
1168 info
->changed_relocs
= true;
1170 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ urel
->r_offset
);
1171 info
->changed_contents
= true;
1174 /* If all mem+byte, we can optimize 32-bit mem displacements. */
1175 else if (fits32
&& !(flags
& ~6))
1177 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
1179 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1181 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
1182 bfd_put_32 (info
->abfd
, lit_insn
,
1183 info
->contents
+ irel
->r_offset
);
1185 info
->changed_contents
= true;
1187 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1189 urel
->r_addend
= irel
->r_addend
;
1190 info
->changed_relocs
= true;
1193 all_optimized
= false;
1196 case 2: /* BYTE OFFSET FORMAT */
1197 /* We can always optimize byte instructions. */
1199 /* FIXME: sanity check the insn for byte op. Check that the
1200 literal dest reg is indeed Rb in the byte insn. */
1202 insn
= (insn
& ~0x001ff000) | ((symval
& 7) << 13) | 0x1000;
1204 urel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1206 info
->changed_relocs
= true;
1208 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ urel
->r_offset
);
1209 info
->changed_contents
= true;
1212 case 3: /* CALL FORMAT */
1214 /* If not zero, place to jump without needing pv. */
1215 bfd_vma optdest
= elf64_alpha_relax_opt_call (info
, symval
);
1216 bfd_vma org
= (info
->sec
->output_section
->vma
1217 + info
->sec
->output_offset
1218 + urel
->r_offset
+ 4);
1219 bfd_signed_vma odisp
;
1221 odisp
= (optdest
? optdest
: symval
) - org
;
1222 if (odisp
>= -0x400000 && odisp
< 0x400000)
1224 Elf_Internal_Rela
*xrel
;
1226 /* Preserve branch prediction call stack when possible. */
1227 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
1228 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
1230 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
1232 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
1234 urel
->r_addend
= irel
->r_addend
;
1237 urel
->r_addend
+= optdest
- symval
;
1239 all_optimized
= false;
1241 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ urel
->r_offset
);
1243 /* Kill any HINT reloc that might exist for this insn. */
1244 xrel
= (elf64_alpha_find_reloc_at_ofs
1245 (info
->relocs
, info
->relend
, urel
->r_offset
,
1248 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1250 info
->changed_contents
= true;
1251 info
->changed_relocs
= true;
1254 all_optimized
= false;
1256 /* ??? If target gp == current gp we can eliminate the gp reload.
1257 This does depend on every place a gp could be reloaded will
1258 be, which currently happens for all code produced by gcc, but
1259 not necessarily by hand-coded assembly, or if sibling calls
1262 Perhaps conditionalize this on a flag being set in the target
1263 object file's header, and have gcc set it? */
1269 /* If all cases were optimized, we can reduce the use count on this
1270 got entry by one, possibly eliminating it. */
1273 info
->gotent
->use_count
-= 1;
1274 alpha_elf_tdata (info
->gotent
->gotobj
)->total_got_entries
-= 1;
1276 alpha_elf_tdata (info
->gotent
->gotobj
)->n_local_got_entries
-= 1;
1278 /* If the literal instruction is no longer needed (it may have been
1279 reused. We can eliminate it.
1280 ??? For now, I don't want to deal with compacting the section,
1281 so just nop it out. */
1284 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
1285 info
->changed_relocs
= true;
1287 bfd_put_32 (info
->abfd
, INSN_UNOP
, info
->contents
+ irel
->r_offset
);
1288 info
->changed_contents
= true;
1292 return irel
+ count
;
1296 elf64_alpha_relax_opt_call (info
, symval
)
1297 struct alpha_relax_info
*info
;
1300 /* If the function has the same gp, and we can identify that the
1301 function does not use its function pointer, we can eliminate the
1304 /* If the symbol is marked NOPV, we are being told the function never
1305 needs its procedure value. */
1306 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
1309 /* If the symbol is marked STD_GP, we are being told the function does
1310 a normal ldgp in the first two words. */
1311 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
1314 /* Otherwise, we may be able to identify a GP load in the first two
1315 words, which we can then skip. */
1318 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
1321 /* Load the relocations from the section that the target symbol is in. */
1322 if (info
->sec
== info
->tsec
)
1324 tsec_relocs
= info
->relocs
;
1325 tsec_relend
= info
->relend
;
1330 tsec_relocs
= (_bfd_elf64_link_read_relocs
1331 (info
->abfd
, info
->tsec
, (PTR
) NULL
,
1332 (Elf_Internal_Rela
*) NULL
,
1333 info
->link_info
->keep_memory
));
1334 if (tsec_relocs
== NULL
)
1336 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
1337 tsec_free
= (info
->link_info
->keep_memory
? NULL
: tsec_relocs
);
1340 /* Recover the symbol's offset within the section. */
1341 ofs
= (symval
- info
->tsec
->output_section
->vma
1342 - info
->tsec
->output_offset
);
1344 /* Look for a GPDISP reloc. */
1345 gpdisp
= (elf64_alpha_find_reloc_at_ofs
1346 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
1348 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
1358 /* We've now determined that we can skip an initial gp load. Verify
1359 that the call and the target use the same gp. */
1360 if (info
->link_info
->hash
->creator
!= info
->tsec
->owner
->xvec
1361 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
1368 elf64_alpha_relax_without_lituse (info
, symval
, irel
)
1369 struct alpha_relax_info
*info
;
1371 Elf_Internal_Rela
*irel
;
1374 bfd_signed_vma disp
;
1376 /* Get the instruction. */
1377 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
1379 if (insn
>> 26 != OP_LDQ
)
1381 ((*_bfd_error_handler
)
1382 ("%s: %s+0x%lx: warning: LITERAL relocation against unexpected insn",
1383 bfd_get_filename (info
->abfd
), info
->sec
->name
,
1384 (unsigned long) irel
->r_offset
));
1388 /* So we aren't told much. Do what we can with the address load and
1389 fake the rest. All of the optimizations here require that the
1390 offset from the GP fit in 16 bits. */
1392 disp
= symval
- info
->gp
;
1393 if (disp
< -0x8000 || disp
>= 0x8000)
1396 /* On the LITERAL instruction itself, consider exchanging
1397 `ldq R,X(gp)' for `lda R,Y(gp)'. */
1399 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
1400 bfd_put_32 (info
->abfd
, insn
, info
->contents
+ irel
->r_offset
);
1401 info
->changed_contents
= true;
1403 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), R_ALPHA_GPRELLOW
);
1404 info
->changed_relocs
= true;
1406 /* Reduce the use count on this got entry by one, possibly
1408 info
->gotent
->use_count
-= 1;
1409 alpha_elf_tdata (info
->gotent
->gotobj
)->total_got_entries
-= 1;
1411 alpha_elf_tdata (info
->gotent
->gotobj
)->n_local_got_entries
-= 1;
1413 /* ??? Search forward through this basic block looking for insns
1414 that use the target register. Stop after an insn modifying the
1415 register is seen, or after a branch or call.
1417 Any such memory load insn may be substituted by a load directly
1418 off the GP. This allows the memory load insn to be issued before
1419 the calculated GP register would otherwise be ready.
1421 Any such jsr insn can be replaced by a bsr if it is in range.
1423 This would mean that we'd have to _add_ relocations, the pain of
1424 which gives one pause. */
1430 elf64_alpha_relax_section (abfd
, sec
, link_info
, again
)
1433 struct bfd_link_info
*link_info
;
1436 Elf_Internal_Shdr
*symtab_hdr
;
1437 Elf_Internal_Rela
*internal_relocs
;
1438 Elf_Internal_Rela
*free_relocs
= NULL
;
1439 Elf_Internal_Rela
*irel
, *irelend
;
1440 bfd_byte
*free_contents
= NULL
;
1441 Elf64_External_Sym
*extsyms
= NULL
;
1442 Elf64_External_Sym
*free_extsyms
= NULL
;
1443 struct alpha_elf_got_entry
**local_got_entries
;
1444 struct alpha_relax_info info
;
1446 /* We are not currently changing any sizes, so only one pass. */
1449 if (link_info
->relocateable
1450 || (sec
->flags
& SEC_RELOC
) == 0
1451 || sec
->reloc_count
== 0)
1454 /* If this is the first time we have been called for this section,
1455 initialize the cooked size. */
1456 if (sec
->_cooked_size
== 0)
1457 sec
->_cooked_size
= sec
->_raw_size
;
1459 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1460 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1462 /* Load the relocations for this section. */
1463 internal_relocs
= (_bfd_elf64_link_read_relocs
1464 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1465 link_info
->keep_memory
));
1466 if (internal_relocs
== NULL
)
1468 if (! link_info
->keep_memory
)
1469 free_relocs
= internal_relocs
;
1471 memset(&info
, 0, sizeof (info
));
1474 info
.link_info
= link_info
;
1475 info
.relocs
= internal_relocs
;
1476 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
1478 /* Find the GP for this object. */
1479 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
1482 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
1483 info
.gp
= _bfd_get_gp_value (info
.gotobj
);
1486 info
.gp
= (sgot
->output_section
->vma
1487 + sgot
->output_offset
1489 _bfd_set_gp_value (info
.gotobj
, info
.gp
);
1493 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1496 Elf_Internal_Sym isym
;
1497 struct alpha_elf_got_entry
*gotent
;
1499 if (ELF64_R_TYPE (irel
->r_info
) != (int) R_ALPHA_LITERAL
)
1502 /* Get the section contents. */
1503 if (info
.contents
== NULL
)
1505 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1506 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
1509 info
.contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
1510 if (info
.contents
== NULL
)
1512 free_contents
= info
.contents
;
1514 if (! bfd_get_section_contents (abfd
, sec
, info
.contents
,
1515 (file_ptr
) 0, sec
->_raw_size
))
1520 /* Read this BFD's symbols if we haven't done so already. */
1521 if (extsyms
== NULL
)
1523 if (symtab_hdr
->contents
!= NULL
)
1524 extsyms
= (Elf64_External_Sym
*) symtab_hdr
->contents
;
1527 extsyms
= ((Elf64_External_Sym
*)
1528 bfd_malloc (symtab_hdr
->sh_size
));
1529 if (extsyms
== NULL
)
1531 free_extsyms
= extsyms
;
1532 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1533 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
1534 != symtab_hdr
->sh_size
))
1539 /* Get the value of the symbol referred to by the reloc. */
1540 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1542 /* A local symbol. */
1543 bfd_elf64_swap_symbol_in (abfd
,
1544 extsyms
+ ELF64_R_SYM (irel
->r_info
),
1546 if (isym
.st_shndx
== SHN_UNDEF
)
1547 info
.tsec
= bfd_und_section_ptr
;
1548 else if (isym
.st_shndx
> 0 && isym
.st_shndx
< SHN_LORESERVE
)
1549 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
1550 else if (isym
.st_shndx
== SHN_ABS
)
1551 info
.tsec
= bfd_abs_section_ptr
;
1552 else if (isym
.st_shndx
== SHN_COMMON
)
1553 info
.tsec
= bfd_com_section_ptr
;
1555 continue; /* who knows. */
1558 info
.other
= isym
.st_other
;
1559 gotent
= local_got_entries
[ELF64_R_SYM(irel
->r_info
)];
1560 symval
= isym
.st_value
;
1565 struct alpha_elf_link_hash_entry
*h
;
1567 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1568 h
= alpha_elf_sym_hashes (abfd
)[indx
];
1569 BFD_ASSERT (h
!= NULL
);
1571 while (h
->root
.root
.type
== bfd_link_hash_indirect
1572 || h
->root
.root
.type
== bfd_link_hash_warning
)
1573 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1575 /* We can't do anthing with undefined or dynamic symbols. */
1576 if (h
->root
.root
.type
== bfd_link_hash_undefined
1577 || h
->root
.root
.type
== bfd_link_hash_undefweak
1578 || alpha_elf_dynamic_symbol_p (&h
->root
, link_info
))
1582 info
.gotent
= gotent
;
1583 info
.tsec
= h
->root
.root
.u
.def
.section
;
1584 info
.other
= h
->root
.other
;
1585 gotent
= h
->got_entries
;
1586 symval
= h
->root
.root
.u
.def
.value
;
1589 /* Search for the got entry to be used by this relocation. */
1590 while (gotent
->gotobj
!= info
.gotobj
|| gotent
->addend
!= irel
->r_addend
)
1591 gotent
= gotent
->next
;
1592 info
.gotent
= gotent
;
1594 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
1595 symval
+= irel
->r_addend
;
1597 BFD_ASSERT(info
.gotent
!= NULL
);
1599 /* If there exist LITUSE relocations immediately following, this
1600 opens up all sorts of interesting optimizations, because we
1601 now know every location that this address load is used. */
1603 if (irel
+1 < irelend
&& ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
1605 irel
= elf64_alpha_relax_with_lituse (&info
, symval
, irel
, irelend
);
1611 if (!elf64_alpha_relax_without_lituse (&info
, symval
, irel
))
1616 if (!elf64_alpha_size_got_sections (abfd
, link_info
))
1619 if (info
.changed_relocs
)
1621 elf_section_data (sec
)->relocs
= internal_relocs
;
1623 else if (free_relocs
!= NULL
)
1628 if (info
.changed_contents
)
1630 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
1632 else if (free_contents
!= NULL
)
1634 if (! link_info
->keep_memory
)
1635 free (free_contents
);
1638 /* Cache the section contents for elf_link_input_bfd. */
1639 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
1643 if (free_extsyms
!= NULL
)
1645 if (! link_info
->keep_memory
)
1646 free (free_extsyms
);
1649 /* Cache the symbols for elf_link_input_bfd. */
1650 symtab_hdr
->contents
= extsyms
;
1654 *again
= info
.changed_contents
|| info
.changed_relocs
;
1659 if (free_relocs
!= NULL
)
1661 if (free_contents
!= NULL
)
1662 free (free_contents
);
1663 if (free_extsyms
!= NULL
)
1664 free (free_extsyms
);
1669 #define PLT_HEADER_SIZE 32
1670 #define PLT_HEADER_WORD1 0xc3600000 /* br $27,.+4 */
1671 #define PLT_HEADER_WORD2 0xa77b000c /* ldq $27,12($27) */
1672 #define PLT_HEADER_WORD3 0x47ff041f /* nop */
1673 #define PLT_HEADER_WORD4 0x6b7b0000 /* jmp $27,($27) */
1675 #define PLT_ENTRY_SIZE 12
1676 #define PLT_ENTRY_WORD1 0xc3800000 /* br $28, plt0 */
1677 #define PLT_ENTRY_WORD2 0
1678 #define PLT_ENTRY_WORD3 0
1680 #define MAX_GOT_ENTRIES (64*1024 / 8)
1682 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
1684 /* Handle an Alpha specific section when reading an object file. This
1685 is called when elfcode.h finds a section with an unknown type.
1686 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1690 elf64_alpha_section_from_shdr (abfd
, hdr
, name
)
1692 Elf64_Internal_Shdr
*hdr
;
1697 /* There ought to be a place to keep ELF backend specific flags, but
1698 at the moment there isn't one. We just keep track of the
1699 sections by their name, instead. Fortunately, the ABI gives
1700 suggested names for all the MIPS specific sections, so we will
1701 probably get away with this. */
1702 switch (hdr
->sh_type
)
1704 case SHT_ALPHA_DEBUG
:
1705 if (strcmp (name
, ".mdebug") != 0)
1708 #ifdef ERIC_neverdef
1709 case SHT_ALPHA_REGINFO
:
1710 if (strcmp (name
, ".reginfo") != 0
1711 || hdr
->sh_size
!= sizeof (Elf64_External_RegInfo
))
1719 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1721 newsect
= hdr
->bfd_section
;
1723 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
1725 if (! bfd_set_section_flags (abfd
, newsect
,
1726 (bfd_get_section_flags (abfd
, newsect
)
1731 #ifdef ERIC_neverdef
1732 /* For a .reginfo section, set the gp value in the tdata information
1733 from the contents of this section. We need the gp value while
1734 processing relocs, so we just get it now. */
1735 if (hdr
->sh_type
== SHT_ALPHA_REGINFO
)
1737 Elf64_External_RegInfo ext
;
1740 if (! bfd_get_section_contents (abfd
, newsect
, (PTR
) &ext
,
1741 (file_ptr
) 0, sizeof ext
))
1743 bfd_alpha_elf64_swap_reginfo_in (abfd
, &ext
, &s
);
1744 elf_gp (abfd
) = s
.ri_gp_value
;
1751 /* Set the correct type for an Alpha ELF section. We do this by the
1752 section name, which is a hack, but ought to work. */
1755 elf64_alpha_fake_sections (abfd
, hdr
, sec
)
1757 Elf64_Internal_Shdr
*hdr
;
1760 register const char *name
;
1762 name
= bfd_get_section_name (abfd
, sec
);
1764 if (strcmp (name
, ".mdebug") == 0)
1766 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
1767 /* In a shared object on Irix 5.3, the .mdebug section has an
1768 entsize of 0. FIXME: Does this matter? */
1769 if ((abfd
->flags
& DYNAMIC
) != 0 )
1770 hdr
->sh_entsize
= 0;
1772 hdr
->sh_entsize
= 1;
1774 #ifdef ERIC_neverdef
1775 else if (strcmp (name
, ".reginfo") == 0)
1777 hdr
->sh_type
= SHT_ALPHA_REGINFO
;
1778 /* In a shared object on Irix 5.3, the .reginfo section has an
1779 entsize of 0x18. FIXME: Does this matter? */
1780 if ((abfd
->flags
& DYNAMIC
) != 0)
1781 hdr
->sh_entsize
= sizeof (Elf64_External_RegInfo
);
1783 hdr
->sh_entsize
= 1;
1785 /* Force the section size to the correct value, even if the
1786 linker thinks it is larger. The link routine below will only
1787 write out this much data for .reginfo. */
1788 hdr
->sh_size
= sec
->_raw_size
= sizeof (Elf64_External_RegInfo
);
1790 else if (strcmp (name
, ".hash") == 0
1791 || strcmp (name
, ".dynamic") == 0
1792 || strcmp (name
, ".dynstr") == 0)
1794 hdr
->sh_entsize
= 0;
1795 hdr
->sh_info
= SIZEOF_ALPHA_DYNSYM_SECNAMES
;
1798 else if (strcmp (name
, ".sdata") == 0
1799 || strcmp (name
, ".sbss") == 0
1800 || strcmp (name
, ".lit4") == 0
1801 || strcmp (name
, ".lit8") == 0)
1802 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
1807 /* Hook called by the linker routine which adds symbols from an object
1808 file. We use it to put .comm items in .sbss, and not .bss. */
1811 elf64_alpha_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1813 struct bfd_link_info
*info
;
1814 const Elf_Internal_Sym
*sym
;
1820 if (sym
->st_shndx
== SHN_COMMON
1821 && !info
->relocateable
1822 && sym
->st_size
<= bfd_get_gp_size (abfd
))
1824 /* Common symbols less than or equal to -G nn bytes are
1825 automatically put into .sbss. */
1827 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1831 scomm
= bfd_make_section (abfd
, ".scommon");
1833 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1835 | SEC_LINKER_CREATED
)))
1840 *valp
= sym
->st_size
;
1846 /* Create the .got section. */
1849 elf64_alpha_create_got_section(abfd
, info
)
1851 struct bfd_link_info
*info
;
1855 if (bfd_get_section_by_name (abfd
, ".got"))
1858 s
= bfd_make_section (abfd
, ".got");
1860 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1863 | SEC_LINKER_CREATED
))
1864 || !bfd_set_section_alignment (abfd
, s
, 3))
1867 alpha_elf_tdata (abfd
)->got
= s
;
1872 /* Create all the dynamic sections. */
1875 elf64_alpha_create_dynamic_sections (abfd
, info
)
1877 struct bfd_link_info
*info
;
1880 struct elf_link_hash_entry
*h
;
1882 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1884 s
= bfd_make_section (abfd
, ".plt");
1886 || ! bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1889 | SEC_LINKER_CREATED
1891 || ! bfd_set_section_alignment (abfd
, s
, 3))
1894 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1897 if (! (_bfd_generic_link_add_one_symbol
1898 (info
, abfd
, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
,
1899 (bfd_vma
) 0, (const char *) NULL
, false,
1900 get_elf_backend_data (abfd
)->collect
,
1901 (struct bfd_link_hash_entry
**) &h
)))
1903 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1904 h
->type
= STT_OBJECT
;
1907 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1910 s
= bfd_make_section (abfd
, ".rela.plt");
1912 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1915 | SEC_LINKER_CREATED
1917 || ! bfd_set_section_alignment (abfd
, s
, 3))
1920 /* We may or may not have created a .got section for this object, but
1921 we definitely havn't done the rest of the work. */
1923 if (!elf64_alpha_create_got_section (abfd
, info
))
1926 s
= bfd_make_section(abfd
, ".rela.got");
1928 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1931 | SEC_LINKER_CREATED
1933 || !bfd_set_section_alignment (abfd
, s
, 3))
1936 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1937 dynobj's .got section. We don't do this in the linker script
1938 because we don't want to define the symbol if we are not creating
1939 a global offset table. */
1941 if (!(_bfd_generic_link_add_one_symbol
1942 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
,
1943 alpha_elf_tdata(abfd
)->got
, (bfd_vma
) 0, (const char *) NULL
,
1944 false, get_elf_backend_data (abfd
)->collect
,
1945 (struct bfd_link_hash_entry
**) &h
)))
1947 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1948 h
->type
= STT_OBJECT
;
1951 && ! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1954 elf_hash_table (info
)->hgot
= h
;
1959 /* Read ECOFF debugging information from a .mdebug section into a
1960 ecoff_debug_info structure. */
1963 elf64_alpha_read_ecoff_info (abfd
, section
, debug
)
1966 struct ecoff_debug_info
*debug
;
1969 const struct ecoff_debug_swap
*swap
;
1970 char *ext_hdr
= NULL
;
1972 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1973 memset (debug
, 0, sizeof (*debug
));
1975 ext_hdr
= (char *) bfd_malloc ((size_t) swap
->external_hdr_size
);
1976 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1979 if (bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
1980 swap
->external_hdr_size
)
1984 symhdr
= &debug
->symbolic_header
;
1985 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1987 /* The symbolic header contains absolute file offsets and sizes to
1989 #define READ(ptr, offset, count, size, type) \
1990 if (symhdr->count == 0) \
1991 debug->ptr = NULL; \
1994 debug->ptr = (type) bfd_malloc ((size_t) (size * symhdr->count)); \
1995 if (debug->ptr == NULL) \
1996 goto error_return; \
1997 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1998 || (bfd_read (debug->ptr, size, symhdr->count, \
1999 abfd) != size * symhdr->count)) \
2000 goto error_return; \
2003 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
2004 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, PTR
);
2005 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, PTR
);
2006 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, PTR
);
2007 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, PTR
);
2008 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
2010 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
2011 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
2012 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, PTR
);
2013 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, PTR
);
2014 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, PTR
);
2018 debug
->adjust
= NULL
;
2023 if (ext_hdr
!= NULL
)
2025 if (debug
->line
!= NULL
)
2027 if (debug
->external_dnr
!= NULL
)
2028 free (debug
->external_dnr
);
2029 if (debug
->external_pdr
!= NULL
)
2030 free (debug
->external_pdr
);
2031 if (debug
->external_sym
!= NULL
)
2032 free (debug
->external_sym
);
2033 if (debug
->external_opt
!= NULL
)
2034 free (debug
->external_opt
);
2035 if (debug
->external_aux
!= NULL
)
2036 free (debug
->external_aux
);
2037 if (debug
->ss
!= NULL
)
2039 if (debug
->ssext
!= NULL
)
2040 free (debug
->ssext
);
2041 if (debug
->external_fdr
!= NULL
)
2042 free (debug
->external_fdr
);
2043 if (debug
->external_rfd
!= NULL
)
2044 free (debug
->external_rfd
);
2045 if (debug
->external_ext
!= NULL
)
2046 free (debug
->external_ext
);
2050 /* Alpha ELF local labels start with '$'. */
2053 elf64_alpha_is_local_label_name (abfd
, name
)
2057 return name
[0] == '$';
2060 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
2061 routine in order to handle the ECOFF debugging information. We
2062 still call this mips_elf_find_line because of the slot
2063 find_line_info in elf_obj_tdata is declared that way. */
2065 struct mips_elf_find_line
2067 struct ecoff_debug_info d
;
2068 struct ecoff_find_line i
;
2072 elf64_alpha_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2073 functionname_ptr
, line_ptr
)
2078 const char **filename_ptr
;
2079 const char **functionname_ptr
;
2080 unsigned int *line_ptr
;
2084 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
2088 struct mips_elf_find_line
*fi
;
2089 const struct ecoff_debug_swap
* const swap
=
2090 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
2092 /* If we are called during a link, alpha_elf_final_link may have
2093 cleared the SEC_HAS_CONTENTS field. We force it back on here
2094 if appropriate (which it normally will be). */
2095 origflags
= msec
->flags
;
2096 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
2097 msec
->flags
|= SEC_HAS_CONTENTS
;
2099 fi
= elf_tdata (abfd
)->find_line_info
;
2102 bfd_size_type external_fdr_size
;
2105 struct fdr
*fdr_ptr
;
2107 fi
= ((struct mips_elf_find_line
*)
2108 bfd_zalloc (abfd
, sizeof (struct mips_elf_find_line
)));
2111 msec
->flags
= origflags
;
2115 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
2117 msec
->flags
= origflags
;
2121 /* Swap in the FDR information. */
2122 fi
->d
.fdr
= ((struct fdr
*)
2124 (fi
->d
.symbolic_header
.ifdMax
*
2125 sizeof (struct fdr
))));
2126 if (fi
->d
.fdr
== NULL
)
2128 msec
->flags
= origflags
;
2131 external_fdr_size
= swap
->external_fdr_size
;
2132 fdr_ptr
= fi
->d
.fdr
;
2133 fraw_src
= (char *) fi
->d
.external_fdr
;
2134 fraw_end
= (fraw_src
2135 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
2136 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
2137 (*swap
->swap_fdr_in
) (abfd
, (PTR
) fraw_src
, fdr_ptr
);
2139 elf_tdata (abfd
)->find_line_info
= fi
;
2141 /* Note that we don't bother to ever free this information.
2142 find_nearest_line is either called all the time, as in
2143 objdump -l, so the information should be saved, or it is
2144 rarely called, as in ld error messages, so the memory
2145 wasted is unimportant. Still, it would probably be a
2146 good idea for free_cached_info to throw it away. */
2149 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
2150 &fi
->i
, filename_ptr
, functionname_ptr
,
2153 msec
->flags
= origflags
;
2157 msec
->flags
= origflags
;
2160 /* Fall back on the generic ELF find_nearest_line routine. */
2162 return _bfd_elf_find_nearest_line (abfd
, section
, symbols
, offset
,
2163 filename_ptr
, functionname_ptr
,
2167 /* Structure used to pass information to alpha_elf_output_extsym. */
2172 struct bfd_link_info
*info
;
2173 struct ecoff_debug_info
*debug
;
2174 const struct ecoff_debug_swap
*swap
;
2179 elf64_alpha_output_extsym (h
, data
)
2180 struct alpha_elf_link_hash_entry
*h
;
2183 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
2185 asection
*sec
, *output_section
;
2187 if (h
->root
.indx
== -2)
2189 else if (((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2190 || (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) != 0)
2191 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0
2192 && (h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_REF_REGULAR
) == 0)
2194 else if (einfo
->info
->strip
== strip_all
2195 || (einfo
->info
->strip
== strip_some
2196 && bfd_hash_lookup (einfo
->info
->keep_hash
,
2197 h
->root
.root
.root
.string
,
2198 false, false) == NULL
))
2206 if (h
->esym
.ifd
== -2)
2209 h
->esym
.cobol_main
= 0;
2210 h
->esym
.weakext
= 0;
2211 h
->esym
.reserved
= 0;
2212 h
->esym
.ifd
= ifdNil
;
2213 h
->esym
.asym
.value
= 0;
2214 h
->esym
.asym
.st
= stGlobal
;
2216 if (h
->root
.root
.type
!= bfd_link_hash_defined
2217 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2218 h
->esym
.asym
.sc
= scAbs
;
2223 sec
= h
->root
.root
.u
.def
.section
;
2224 output_section
= sec
->output_section
;
2226 /* When making a shared library and symbol h is the one from
2227 the another shared library, OUTPUT_SECTION may be null. */
2228 if (output_section
== NULL
)
2229 h
->esym
.asym
.sc
= scUndefined
;
2232 name
= bfd_section_name (output_section
->owner
, output_section
);
2234 if (strcmp (name
, ".text") == 0)
2235 h
->esym
.asym
.sc
= scText
;
2236 else if (strcmp (name
, ".data") == 0)
2237 h
->esym
.asym
.sc
= scData
;
2238 else if (strcmp (name
, ".sdata") == 0)
2239 h
->esym
.asym
.sc
= scSData
;
2240 else if (strcmp (name
, ".rodata") == 0
2241 || strcmp (name
, ".rdata") == 0)
2242 h
->esym
.asym
.sc
= scRData
;
2243 else if (strcmp (name
, ".bss") == 0)
2244 h
->esym
.asym
.sc
= scBss
;
2245 else if (strcmp (name
, ".sbss") == 0)
2246 h
->esym
.asym
.sc
= scSBss
;
2247 else if (strcmp (name
, ".init") == 0)
2248 h
->esym
.asym
.sc
= scInit
;
2249 else if (strcmp (name
, ".fini") == 0)
2250 h
->esym
.asym
.sc
= scFini
;
2252 h
->esym
.asym
.sc
= scAbs
;
2256 h
->esym
.asym
.reserved
= 0;
2257 h
->esym
.asym
.index
= indexNil
;
2260 if (h
->root
.root
.type
== bfd_link_hash_common
)
2261 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
2262 else if (h
->root
.root
.type
== bfd_link_hash_defined
2263 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2265 if (h
->esym
.asym
.sc
== scCommon
)
2266 h
->esym
.asym
.sc
= scBss
;
2267 else if (h
->esym
.asym
.sc
== scSCommon
)
2268 h
->esym
.asym
.sc
= scSBss
;
2270 sec
= h
->root
.root
.u
.def
.section
;
2271 output_section
= sec
->output_section
;
2272 if (output_section
!= NULL
)
2273 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
2274 + sec
->output_offset
2275 + output_section
->vma
);
2277 h
->esym
.asym
.value
= 0;
2279 else if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
2281 /* Set type and value for a symbol with a function stub. */
2282 h
->esym
.asym
.st
= stProc
;
2283 sec
= bfd_get_section_by_name (einfo
->abfd
, ".plt");
2285 h
->esym
.asym
.value
= 0;
2288 output_section
= sec
->output_section
;
2289 if (output_section
!= NULL
)
2290 h
->esym
.asym
.value
= (h
->root
.plt
.offset
2291 + sec
->output_offset
2292 + output_section
->vma
);
2294 h
->esym
.asym
.value
= 0;
2301 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
2302 h
->root
.root
.root
.string
,
2305 einfo
->failed
= true;
2312 /* FIXME: Create a runtime procedure table from the .mdebug section.
2315 mips_elf_create_procedure_table (handle, abfd, info, s, debug)
2318 struct bfd_link_info *info;
2320 struct ecoff_debug_info *debug;
2323 /* Handle dynamic relocations when doing an Alpha ELF link. */
2326 elf64_alpha_check_relocs (abfd
, info
, sec
, relocs
)
2328 struct bfd_link_info
*info
;
2330 const Elf_Internal_Rela
*relocs
;
2334 const char *rel_sec_name
;
2335 Elf_Internal_Shdr
*symtab_hdr
;
2336 struct alpha_elf_link_hash_entry
**sym_hashes
;
2337 struct alpha_elf_got_entry
**local_got_entries
;
2338 const Elf_Internal_Rela
*rel
, *relend
;
2341 if (info
->relocateable
)
2344 dynobj
= elf_hash_table(info
)->dynobj
;
2346 elf_hash_table(info
)->dynobj
= dynobj
= abfd
;
2349 rel_sec_name
= NULL
;
2350 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
2351 sym_hashes
= alpha_elf_sym_hashes(abfd
);
2352 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
2355 relend
= relocs
+ sec
->reloc_count
;
2356 for (rel
= relocs
; rel
< relend
; ++rel
)
2358 unsigned long r_symndx
, r_type
;
2359 struct alpha_elf_link_hash_entry
*h
;
2361 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2362 if (r_symndx
< symtab_hdr
->sh_info
)
2366 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2368 while (h
->root
.root
.type
== bfd_link_hash_indirect
2369 || h
->root
.root
.type
== bfd_link_hash_warning
)
2370 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2372 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2374 r_type
= ELF64_R_TYPE (rel
->r_info
);
2378 case R_ALPHA_LITERAL
:
2380 struct alpha_elf_got_entry
*gotent
;
2385 /* Search for and possibly create a got entry. */
2386 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2387 if (gotent
->gotobj
== abfd
&&
2388 gotent
->addend
== rel
->r_addend
)
2393 gotent
= ((struct alpha_elf_got_entry
*)
2395 sizeof (struct alpha_elf_got_entry
)));
2399 gotent
->gotobj
= abfd
;
2400 gotent
->addend
= rel
->r_addend
;
2401 gotent
->got_offset
= -1;
2403 gotent
->use_count
= 1;
2405 gotent
->next
= h
->got_entries
;
2406 h
->got_entries
= gotent
;
2408 alpha_elf_tdata (abfd
)->total_got_entries
++;
2411 gotent
->use_count
+= 1;
2415 /* This is a local .got entry -- record for merge. */
2416 if (!local_got_entries
)
2419 size
= (symtab_hdr
->sh_info
2420 * sizeof (struct alpha_elf_got_entry
*));
2422 local_got_entries
= ((struct alpha_elf_got_entry
**)
2423 bfd_alloc (abfd
, size
));
2424 if (!local_got_entries
)
2427 memset (local_got_entries
, 0, size
);
2428 alpha_elf_tdata (abfd
)->local_got_entries
=
2432 for (gotent
= local_got_entries
[ELF64_R_SYM(rel
->r_info
)];
2433 gotent
!= NULL
&& gotent
->addend
!= rel
->r_addend
;
2434 gotent
= gotent
->next
)
2438 gotent
= ((struct alpha_elf_got_entry
*)
2440 sizeof (struct alpha_elf_got_entry
)));
2444 gotent
->gotobj
= abfd
;
2445 gotent
->addend
= rel
->r_addend
;
2446 gotent
->got_offset
= -1;
2448 gotent
->use_count
= 1;
2450 gotent
->next
= local_got_entries
[ELF64_R_SYM(rel
->r_info
)];
2451 local_got_entries
[ELF64_R_SYM(rel
->r_info
)] = gotent
;
2453 alpha_elf_tdata(abfd
)->total_got_entries
++;
2454 alpha_elf_tdata(abfd
)->n_local_got_entries
++;
2457 gotent
->use_count
+= 1;
2460 /* Remember how this literal is used from its LITUSEs.
2461 This will be important when it comes to decide if we can
2462 create a .plt entry for a function symbol. */
2464 && ELF64_R_TYPE (rel
[1].r_info
) == R_ALPHA_LITUSE
)
2469 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 3)
2470 flags
|= 1 << rel
->r_addend
;
2472 while (rel
+1 < relend
&&
2473 ELF64_R_TYPE (rel
[1].r_info
) == R_ALPHA_LITUSE
);
2477 /* No LITUSEs -- presumably the address is not being
2478 loaded for nothing. */
2479 flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
2482 gotent
->flags
|= flags
;
2485 /* Make a guess as to whether a .plt entry will be needed. */
2486 if ((h
->flags
|= flags
) == ALPHA_ELF_LINK_HASH_LU_FUNC
)
2487 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2489 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2494 case R_ALPHA_GPDISP
:
2495 case R_ALPHA_GPREL32
:
2496 case R_ALPHA_GPRELHIGH
:
2497 case R_ALPHA_GPRELLOW
:
2498 /* We don't actually use the .got here, but the sections must
2499 be created before the linker maps input sections to output
2503 if (!elf64_alpha_create_got_section (abfd
, info
))
2506 /* Make sure the object's gotobj is set to itself so
2507 that we default to every object with its own .got.
2508 We'll merge .gots later once we've collected each
2510 alpha_elf_tdata(abfd
)->gotobj
= abfd
;
2516 case R_ALPHA_SREL16
:
2517 case R_ALPHA_SREL32
:
2518 case R_ALPHA_SREL64
:
2523 case R_ALPHA_REFLONG
:
2524 case R_ALPHA_REFQUAD
:
2525 if (rel_sec_name
== NULL
)
2527 rel_sec_name
= (bfd_elf_string_from_elf_section
2528 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2529 elf_section_data(sec
)->rel_hdr
.sh_name
));
2530 if (rel_sec_name
== NULL
)
2533 BFD_ASSERT (strncmp (rel_sec_name
, ".rela", 5) == 0
2534 && strcmp (bfd_get_section_name (abfd
, sec
),
2535 rel_sec_name
+5) == 0);
2538 /* We need to create the section here now whether we eventually
2539 use it or not so that it gets mapped to an output section by
2540 the linker. If not used, we'll kill it in
2541 size_dynamic_sections. */
2544 sreloc
= bfd_get_section_by_name (dynobj
, rel_sec_name
);
2547 sreloc
= bfd_make_section (dynobj
, rel_sec_name
);
2549 || !bfd_set_section_flags (dynobj
, sreloc
,
2550 ((sec
->flags
& (SEC_ALLOC
2554 | SEC_LINKER_CREATED
2556 || !bfd_set_section_alignment (dynobj
, sreloc
, 3))
2563 /* Since we havn't seen all of the input symbols yet, we
2564 don't know whether we'll actually need a dynamic relocation
2565 entry for this reloc. So make a record of it. Once we
2566 find out if this thing needs dynamic relocation we'll
2567 expand the relocation sections by the appropriate amount. */
2569 struct alpha_elf_reloc_entry
*rent
;
2571 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
2572 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
2577 rent
= ((struct alpha_elf_reloc_entry
*)
2579 sizeof (struct alpha_elf_reloc_entry
)));
2583 rent
->srel
= sreloc
;
2584 rent
->rtype
= r_type
;
2587 rent
->next
= h
->reloc_entries
;
2588 h
->reloc_entries
= rent
;
2593 else if (info
->shared
&& (sec
->flags
& SEC_ALLOC
))
2595 /* If this is a shared library, and the section is to be
2596 loaded into memory, we need a RELATIVE reloc. */
2597 sreloc
->_raw_size
+= sizeof (Elf64_External_Rela
);
2606 /* Adjust a symbol defined by a dynamic object and referenced by a
2607 regular object. The current definition is in some section of the
2608 dynamic object, but we're not including those sections. We have to
2609 change the definition to something the rest of the link can
2613 elf64_alpha_adjust_dynamic_symbol (info
, h
)
2614 struct bfd_link_info
*info
;
2615 struct elf_link_hash_entry
*h
;
2619 struct alpha_elf_link_hash_entry
*ah
;
2621 dynobj
= elf_hash_table(info
)->dynobj
;
2622 ah
= (struct alpha_elf_link_hash_entry
*)h
;
2624 /* Now that we've seen all of the input symbols, finalize our decision
2625 about whether this symbol should get a .plt entry. */
2627 if (h
->root
.type
!= bfd_link_hash_undefweak
2628 && alpha_elf_dynamic_symbol_p (h
, info
)
2629 && ((h
->type
== STT_FUNC
2630 && !(ah
->flags
& ALPHA_ELF_LINK_HASH_LU_ADDR
))
2631 || (h
->type
== STT_NOTYPE
2632 && ah
->flags
== ALPHA_ELF_LINK_HASH_LU_FUNC
))
2633 /* Don't prevent otherwise valid programs from linking by attempting
2634 to create a new .got entry somewhere. A Correct Solution would be
2635 to add a new .got section to a new object file and let it be merged
2636 somewhere later. But for now don't bother. */
2639 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2641 s
= bfd_get_section_by_name(dynobj
, ".plt");
2642 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
2645 /* The first bit of the .plt is reserved. */
2646 if (s
->_raw_size
== 0)
2647 s
->_raw_size
= PLT_HEADER_SIZE
;
2649 h
->plt
.offset
= s
->_raw_size
;
2650 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2652 /* If this symbol is not defined in a regular file, and we are not
2653 generating a shared library, then set the symbol to the location
2654 in the .plt. This is required to make function pointers compare
2655 equal between the normal executable and the shared library. */
2657 && h
->root
.type
!= bfd_link_hash_defweak
)
2659 h
->root
.u
.def
.section
= s
;
2660 h
->root
.u
.def
.value
= h
->plt
.offset
;
2663 /* We also need a JMP_SLOT entry in the .rela.plt section. */
2664 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
2665 BFD_ASSERT (s
!= NULL
);
2666 s
->_raw_size
+= sizeof (Elf64_External_Rela
);
2671 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2673 /* If this is a weak symbol, and there is a real definition, the
2674 processor independent code will have arranged for us to see the
2675 real definition first, and we can just use the same value. */
2676 if (h
->weakdef
!= NULL
)
2678 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2679 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2680 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2681 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2685 /* This is a reference to a symbol defined by a dynamic object which
2686 is not a function. The Alpha, since it uses .got entries for all
2687 symbols even in regular objects, does not need the hackery of a
2688 .dynbss section and COPY dynamic relocations. */
2693 /* Symbol versioning can create new symbols, and make our old symbols
2694 indirect to the new ones. Consolidate the got and reloc information
2695 in these situations. */
2698 elf64_alpha_merge_ind_symbols (hi
, dummy
)
2699 struct alpha_elf_link_hash_entry
*hi
;
2702 struct alpha_elf_link_hash_entry
*hs
;
2704 if (hi
->root
.root
.type
!= bfd_link_hash_indirect
)
2708 hs
= (struct alpha_elf_link_hash_entry
*)hs
->root
.root
.u
.i
.link
;
2709 } while (hs
->root
.root
.type
== bfd_link_hash_indirect
);
2711 /* Merge the flags. Whee. */
2713 hs
->flags
|= hi
->flags
;
2715 /* Merge the .got entries. Cannibalize the old symbol's list in
2716 doing so, since we don't need it anymore. */
2718 if (hs
->got_entries
== NULL
)
2719 hs
->got_entries
= hi
->got_entries
;
2722 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
2724 gsh
= hs
->got_entries
;
2725 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
2728 for (gs
= gsh
; gs
; gs
= gs
->next
)
2729 if (gi
->gotobj
== gs
->gotobj
&& gi
->addend
== gs
->addend
)
2731 gi
->next
= hs
->got_entries
;
2732 hs
->got_entries
= gi
;
2736 hi
->got_entries
= NULL
;
2738 /* And similar for the reloc entries. */
2740 if (hs
->reloc_entries
== NULL
)
2741 hs
->reloc_entries
= hi
->reloc_entries
;
2744 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
2746 rsh
= hs
->reloc_entries
;
2747 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
2750 for (rs
= rsh
; rs
; rs
= rs
->next
)
2751 if (ri
->rtype
== rs
->rtype
)
2753 rs
->count
+= ri
->count
;
2756 ri
->next
= hs
->reloc_entries
;
2757 hs
->reloc_entries
= ri
;
2761 hi
->reloc_entries
= NULL
;
2766 /* Is it possible to merge two object file's .got tables? */
2769 elf64_alpha_can_merge_gots (a
, b
)
2772 int total
= alpha_elf_tdata (a
)->total_got_entries
;
2775 /* Trivial quick fallout test. */
2776 if (total
+ alpha_elf_tdata (b
)->total_got_entries
<= MAX_GOT_ENTRIES
)
2779 /* By their nature, local .got entries cannot be merged. */
2780 if ((total
+= alpha_elf_tdata (b
)->n_local_got_entries
) > MAX_GOT_ENTRIES
)
2783 /* Failing the common trivial comparison, we must effectively
2784 perform the merge. Not actually performing the merge means that
2785 we don't have to store undo information in case we fail. */
2786 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2788 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
2789 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2792 n
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
- symtab_hdr
->sh_info
;
2793 for (i
= 0; i
< n
; ++i
)
2795 struct alpha_elf_got_entry
*ae
, *be
;
2796 struct alpha_elf_link_hash_entry
*h
;
2799 while (h
->root
.root
.type
== bfd_link_hash_indirect
2800 || h
->root
.root
.type
== bfd_link_hash_warning
)
2801 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2803 for (be
= h
->got_entries
; be
; be
= be
->next
)
2805 if (be
->use_count
== 0)
2807 if (be
->gotobj
!= b
)
2810 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
2811 if (ae
->gotobj
== a
&& ae
->addend
== be
->addend
)
2814 if (++total
> MAX_GOT_ENTRIES
)
2824 /* Actually merge two .got tables. */
2827 elf64_alpha_merge_gots (a
, b
)
2830 int total
= alpha_elf_tdata (a
)->total_got_entries
;
2833 /* Remember local expansion. */
2835 int e
= alpha_elf_tdata (b
)->n_local_got_entries
;
2837 alpha_elf_tdata (a
)->n_local_got_entries
+= e
;
2840 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2842 struct alpha_elf_got_entry
**local_got_entries
;
2843 struct alpha_elf_link_hash_entry
**hashes
;
2844 Elf_Internal_Shdr
*symtab_hdr
;
2847 /* Let the local .got entries know they are part of a new subsegment. */
2848 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
2849 if (local_got_entries
)
2851 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
2852 for (i
= 0; i
< n
; ++i
)
2854 struct alpha_elf_got_entry
*ent
;
2855 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
2860 /* Merge the global .got entries. */
2861 hashes
= alpha_elf_sym_hashes (bsub
);
2862 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2864 n
= symtab_hdr
->sh_size
/ symtab_hdr
->sh_entsize
- symtab_hdr
->sh_info
;
2865 for (i
= 0; i
< n
; ++i
)
2867 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
2868 struct alpha_elf_link_hash_entry
*h
;
2871 while (h
->root
.root
.type
== bfd_link_hash_indirect
2872 || h
->root
.root
.type
== bfd_link_hash_warning
)
2873 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2875 start
= &h
->got_entries
;
2876 for (pbe
= start
, be
= *start
; be
; pbe
= &be
->next
, be
= be
->next
)
2878 if (be
->use_count
== 0)
2883 if (be
->gotobj
!= b
)
2886 for (ae
= *start
; ae
; ae
= ae
->next
)
2887 if (ae
->gotobj
== a
&& ae
->addend
== be
->addend
)
2889 ae
->flags
|= be
->flags
;
2890 ae
->use_count
+= be
->use_count
;
2901 alpha_elf_tdata (bsub
)->gotobj
= a
;
2903 alpha_elf_tdata (a
)->total_got_entries
= total
;
2905 /* Merge the two in_got chains. */
2910 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
2913 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
2917 /* Calculate the offsets for the got entries. */
2920 elf64_alpha_calc_got_offsets_for_symbol (h
, arg
)
2921 struct alpha_elf_link_hash_entry
*h
;
2924 struct alpha_elf_got_entry
*gotent
;
2926 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2927 if (gotent
->use_count
> 0)
2930 = &alpha_elf_tdata (gotent
->gotobj
)->got
->_raw_size
;
2932 gotent
->got_offset
= *plge
;
2940 elf64_alpha_calc_got_offsets (info
)
2941 struct bfd_link_info
*info
;
2943 bfd
*i
, *got_list
= alpha_elf_hash_table(info
)->got_list
;
2945 /* First, zero out the .got sizes, as we may be recalculating the
2946 .got after optimizing it. */
2947 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2948 alpha_elf_tdata(i
)->got
->_raw_size
= 0;
2950 /* Next, fill in the offsets for all the global entries. */
2951 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
2952 elf64_alpha_calc_got_offsets_for_symbol
,
2955 /* Finally, fill in the offsets for the local entries. */
2956 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2958 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->_raw_size
;
2961 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
2963 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
2966 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
2967 if (!local_got_entries
)
2970 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
2971 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
2972 if (gotent
->use_count
> 0)
2974 gotent
->got_offset
= got_offset
;
2979 alpha_elf_tdata(i
)->got
->_raw_size
= got_offset
;
2980 alpha_elf_tdata(i
)->got
->_cooked_size
= got_offset
;
2984 /* Constructs the gots. */
2987 elf64_alpha_size_got_sections (output_bfd
, info
)
2989 struct bfd_link_info
*info
;
2991 bfd
*i
, *got_list
, *cur_got_obj
;
2992 int something_changed
= 0;
2994 got_list
= alpha_elf_hash_table (info
)->got_list
;
2996 /* On the first time through, pretend we have an existing got list
2997 consisting of all of the input files. */
2998 if (got_list
== NULL
)
3000 for (i
= info
->input_bfds
; i
; i
= i
->link_next
)
3002 bfd
*this_got
= alpha_elf_tdata (i
)->gotobj
;
3003 if (this_got
== NULL
)
3006 /* We are assuming no merging has yet ocurred. */
3007 BFD_ASSERT (this_got
== i
);
3009 if (alpha_elf_tdata (this_got
)->total_got_entries
> MAX_GOT_ENTRIES
)
3011 /* Yikes! A single object file has too many entries. */
3012 (*_bfd_error_handler
)
3013 (_("%s: .got subsegment exceeds 64K (size %d)"),
3014 bfd_get_filename (i
),
3015 alpha_elf_tdata (this_got
)->total_got_entries
* 8);
3019 if (got_list
== NULL
)
3020 got_list
= this_got
;
3022 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
3023 cur_got_obj
= this_got
;
3026 /* Strange degenerate case of no got references. */
3027 if (got_list
== NULL
)
3030 alpha_elf_hash_table (info
)->got_list
= got_list
;
3032 /* Force got offsets to be recalculated. */
3033 something_changed
= 1;
3036 cur_got_obj
= got_list
;
3037 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
3040 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
3042 elf64_alpha_merge_gots (cur_got_obj
, i
);
3043 i
= alpha_elf_tdata(i
)->got_link_next
;
3044 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
3045 something_changed
= 1;
3050 i
= alpha_elf_tdata(i
)->got_link_next
;
3054 /* Once the gots have been merged, fill in the got offsets for
3055 everything therein. */
3056 if (1 || something_changed
)
3057 elf64_alpha_calc_got_offsets (info
);
3063 elf64_alpha_always_size_sections (output_bfd
, info
)
3065 struct bfd_link_info
*info
;
3069 if (info
->relocateable
)
3072 /* First, take care of the indirect symbols created by versioning. */
3073 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3074 elf64_alpha_merge_ind_symbols
,
3077 if (!elf64_alpha_size_got_sections (output_bfd
, info
))
3080 /* Allocate space for all of the .got subsections. */
3081 i
= alpha_elf_hash_table (info
)->got_list
;
3082 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
3084 asection
*s
= alpha_elf_tdata(i
)->got
;
3085 if (s
->_raw_size
> 0)
3087 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->_raw_size
);
3088 if (s
->contents
== NULL
)
3096 /* Work out the sizes of the dynamic relocation entries. */
3099 elf64_alpha_calc_dynrel_sizes (h
, info
)
3100 struct alpha_elf_link_hash_entry
*h
;
3101 struct bfd_link_info
*info
;
3103 /* If the symbol was defined as a common symbol in a regular object
3104 file, and there was no definition in any dynamic object, then the
3105 linker will have allocated space for the symbol in a common
3106 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
3107 set. This is done for dynamic symbols in
3108 elf_adjust_dynamic_symbol but this is not done for non-dynamic
3109 symbols, somehow. */
3110 if (((h
->root
.elf_link_hash_flags
3111 & (ELF_LINK_HASH_DEF_REGULAR
3112 | ELF_LINK_HASH_REF_REGULAR
3113 | ELF_LINK_HASH_DEF_DYNAMIC
))
3114 == ELF_LINK_HASH_REF_REGULAR
)
3115 && (h
->root
.root
.type
== bfd_link_hash_defined
3116 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3117 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3119 h
->root
.elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
3122 /* If the symbol is dynamic, we'll need all the relocations in their
3123 natural form. If this is a shared object, and it has been forced
3124 local, we'll need the same number of RELATIVE relocations. */
3126 if (alpha_elf_dynamic_symbol_p (&h
->root
, info
) || info
->shared
)
3128 struct alpha_elf_reloc_entry
*relent
;
3130 struct alpha_elf_got_entry
*gotent
;
3131 bfd_size_type count
;
3134 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
3135 if (relent
->rtype
== R_ALPHA_REFLONG
3136 || relent
->rtype
== R_ALPHA_REFQUAD
)
3138 relent
->srel
->_raw_size
+=
3139 sizeof (Elf64_External_Rela
) * relent
->count
;
3142 dynobj
= elf_hash_table(info
)->dynobj
;
3145 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
3148 /* If we are using a .plt entry, subtract one, as the first
3149 reference uses a .rela.plt entry instead. */
3150 if (h
->root
.plt
.offset
!= MINUS_ONE
)
3155 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3156 BFD_ASSERT (srel
!= NULL
);
3157 srel
->_raw_size
+= sizeof (Elf64_External_Rela
) * count
;
3164 /* Set the sizes of the dynamic sections. */
3167 elf64_alpha_size_dynamic_sections (output_bfd
, info
)
3169 struct bfd_link_info
*info
;
3176 dynobj
= elf_hash_table(info
)->dynobj
;
3177 BFD_ASSERT(dynobj
!= NULL
);
3179 if (elf_hash_table (info
)->dynamic_sections_created
)
3181 /* Set the contents of the .interp section to the interpreter. */
3184 s
= bfd_get_section_by_name (dynobj
, ".interp");
3185 BFD_ASSERT (s
!= NULL
);
3186 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
3187 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
3190 /* Now that we've seen all of the input files, we can decide which
3191 symbols need dynamic relocation entries and which don't. We've
3192 collected information in check_relocs that we can now apply to
3193 size the dynamic relocation sections. */
3194 alpha_elf_link_hash_traverse (alpha_elf_hash_table (info
),
3195 elf64_alpha_calc_dynrel_sizes
,
3198 /* When building shared libraries, each local .got entry needs a
3204 bfd_size_type count
;
3206 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3207 BFD_ASSERT (srel
!= NULL
);
3209 for (i
= alpha_elf_hash_table(info
)->got_list
, count
= 0;
3211 i
= alpha_elf_tdata(i
)->got_link_next
)
3212 count
+= alpha_elf_tdata(i
)->n_local_got_entries
;
3214 srel
->_raw_size
+= count
* sizeof (Elf64_External_Rela
);
3217 /* else we're not dynamic and by definition we don't need such things. */
3219 /* The check_relocs and adjust_dynamic_symbol entry points have
3220 determined the sizes of the various dynamic sections. Allocate
3224 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3229 if (!(s
->flags
& SEC_LINKER_CREATED
))
3232 /* It's OK to base decisions on the section name, because none
3233 of the dynobj section names depend upon the input files. */
3234 name
= bfd_get_section_name (dynobj
, s
);
3236 /* If we don't need this section, strip it from the output file.
3237 This is to handle .rela.bss and .rela.plt. We must create it
3238 in create_dynamic_sections, because it must be created before
3239 the linker maps input sections to output sections. The
3240 linker does that before adjust_dynamic_symbol is called, and
3241 it is that function which decides whether anything needs to
3242 go into these sections. */
3246 if (strncmp (name
, ".rela", 5) == 0)
3248 strip
= (s
->_raw_size
== 0);
3252 const char *outname
;
3255 /* If this relocation section applies to a read only
3256 section, then we probably need a DT_TEXTREL entry. */
3257 outname
= bfd_get_section_name (output_bfd
,
3259 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
3261 && (target
->flags
& SEC_READONLY
) != 0
3262 && (target
->flags
& SEC_ALLOC
) != 0)
3265 if (strcmp(name
, ".rela.plt") == 0)
3268 /* We use the reloc_count field as a counter if we need
3269 to copy relocs into the output file. */
3273 else if (strcmp (name
, ".plt") != 0)
3275 /* It's not one of our dynamic sections, so don't allocate space. */
3280 _bfd_strip_section_from_output (info
, s
);
3283 /* Allocate memory for the section contents. */
3284 s
->contents
= (bfd_byte
*) bfd_zalloc(dynobj
, s
->_raw_size
);
3285 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
3290 if (elf_hash_table (info
)->dynamic_sections_created
)
3292 /* Add some entries to the .dynamic section. We fill in the
3293 values later, in elf64_alpha_finish_dynamic_sections, but we
3294 must add the entries now so that we get the correct size for
3295 the .dynamic section. The DT_DEBUG entry is filled in by the
3296 dynamic linker and used by the debugger. */
3299 if (!bfd_elf64_add_dynamic_entry (info
, DT_DEBUG
, 0))
3303 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTGOT
, 0))
3308 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
3309 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
3310 || ! bfd_elf64_add_dynamic_entry (info
, DT_JMPREL
, 0))
3314 if (! bfd_elf64_add_dynamic_entry (info
, DT_RELA
, 0)
3315 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELASZ
, 0)
3316 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELAENT
,
3317 sizeof (Elf64_External_Rela
)))
3322 if (! bfd_elf64_add_dynamic_entry (info
, DT_TEXTREL
, 0))
3324 info
->flags
|= DF_TEXTREL
;
3331 /* Relocate an Alpha ELF section. */
3334 elf64_alpha_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3335 contents
, relocs
, local_syms
, local_sections
)
3337 struct bfd_link_info
*info
;
3339 asection
*input_section
;
3341 Elf_Internal_Rela
*relocs
;
3342 Elf_Internal_Sym
*local_syms
;
3343 asection
**local_sections
;
3345 Elf_Internal_Shdr
*symtab_hdr
;
3346 Elf_Internal_Rela
*rel
;
3347 Elf_Internal_Rela
*relend
;
3348 asection
*sec
, *sgot
, *srel
, *srelgot
;
3349 bfd
*dynobj
, *gotobj
;
3352 srelgot
= srel
= NULL
;
3353 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3354 dynobj
= elf_hash_table (info
)->dynobj
;
3357 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
3360 /* Find the gp value for this input bfd. */
3363 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
3366 sgot
= alpha_elf_tdata (gotobj
)->got
;
3367 gp
= _bfd_get_gp_value (gotobj
);
3370 gp
= (sgot
->output_section
->vma
3371 + sgot
->output_offset
3373 _bfd_set_gp_value (gotobj
, gp
);
3378 relend
= relocs
+ input_section
->reloc_count
;
3379 for (; rel
< relend
; rel
++)
3382 reloc_howto_type
*howto
;
3383 unsigned long r_symndx
;
3384 struct alpha_elf_link_hash_entry
*h
;
3385 Elf_Internal_Sym
*sym
;
3388 bfd_reloc_status_type r
;
3390 r_type
= ELF64_R_TYPE(rel
->r_info
);
3391 if (r_type
< 0 || r_type
>= (int) R_ALPHA_max
)
3393 bfd_set_error (bfd_error_bad_value
);
3396 howto
= elf64_alpha_howto_table
+ r_type
;
3398 r_symndx
= ELF64_R_SYM(rel
->r_info
);
3400 if (info
->relocateable
)
3402 /* This is a relocateable link. We don't have to change
3403 anything, unless the reloc is against a section symbol,
3404 in which case we have to adjust according to where the
3405 section symbol winds up in the output section. */
3407 /* The symbol associated with GPDISP and LITUSE is
3408 immaterial. Only the addend is significant. */
3409 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
3412 if (r_symndx
< symtab_hdr
->sh_info
)
3414 sym
= local_syms
+ r_symndx
;
3415 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
3417 sec
= local_sections
[r_symndx
];
3418 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
3425 /* This is a final link. */
3431 if (r_symndx
< symtab_hdr
->sh_info
)
3433 sym
= local_syms
+ r_symndx
;
3434 sec
= local_sections
[r_symndx
];
3435 relocation
= (sec
->output_section
->vma
3436 + sec
->output_offset
3441 h
= alpha_elf_sym_hashes (input_bfd
)[r_symndx
- symtab_hdr
->sh_info
];
3443 while (h
->root
.root
.type
== bfd_link_hash_indirect
3444 || h
->root
.root
.type
== bfd_link_hash_warning
)
3445 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3447 if (h
->root
.root
.type
== bfd_link_hash_defined
3448 || h
->root
.root
.type
== bfd_link_hash_defweak
)
3450 sec
= h
->root
.root
.u
.def
.section
;
3453 if ((r_type
== R_ALPHA_LITERAL
3454 && elf_hash_table(info
)->dynamic_sections_created
3457 || !(h
->root
.elf_link_hash_flags
3458 & ELF_LINK_HASH_DEF_REGULAR
)))
3461 || !(h
->root
.elf_link_hash_flags
3462 & ELF_LINK_HASH_DEF_REGULAR
))
3463 && (input_section
->flags
& SEC_ALLOC
)
3464 && (r_type
== R_ALPHA_REFLONG
3465 || r_type
== R_ALPHA_REFQUAD
3466 || r_type
== R_ALPHA_LITERAL
)))
3468 /* In these cases, we don't need the relocation value.
3469 We check specially because in some obscure cases
3470 sec->output_section will be NULL. */
3474 /* FIXME: Are not these obscure cases simply bugs? Let's
3475 get something working and come back to this. */
3476 if (sec
->output_section
== NULL
)
3478 #endif /* rth_notdef */
3481 relocation
= (h
->root
.root
.u
.def
.value
3482 + sec
->output_section
->vma
3483 + sec
->output_offset
);
3486 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3488 else if (info
->shared
&& !info
->symbolic
3489 && !info
->no_undefined
3490 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
3494 if (!((*info
->callbacks
->undefined_symbol
)
3495 (info
, h
->root
.root
.root
.string
, input_bfd
,
3496 input_section
, rel
->r_offset
,
3497 (!info
->shared
|| info
->no_undefined
3498 || ELF_ST_VISIBILITY (h
->root
.other
)))))
3503 addend
= rel
->r_addend
;
3507 case R_ALPHA_GPDISP
:
3509 bfd_byte
*p_ldah
, *p_lda
;
3511 BFD_ASSERT(gp
!= 0);
3513 relocation
= (input_section
->output_section
->vma
3514 + input_section
->output_offset
3517 p_ldah
= contents
+ rel
->r_offset
- input_section
->vma
;
3518 p_lda
= p_ldah
+ rel
->r_addend
;
3520 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- relocation
,
3525 case R_ALPHA_OP_PUSH
:
3526 case R_ALPHA_OP_STORE
:
3527 case R_ALPHA_OP_PSUB
:
3528 case R_ALPHA_OP_PRSHIFT
:
3529 /* We hate these silly beasts. */
3532 case R_ALPHA_LITERAL
:
3534 struct alpha_elf_got_entry
*gotent
;
3535 boolean dynamic_symbol
;
3537 BFD_ASSERT(sgot
!= NULL
);
3538 BFD_ASSERT(gp
!= 0);
3542 gotent
= h
->got_entries
;
3543 dynamic_symbol
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
3547 gotent
= (alpha_elf_tdata(input_bfd
)->
3548 local_got_entries
[r_symndx
]);
3549 dynamic_symbol
= false;
3552 BFD_ASSERT(gotent
!= NULL
);
3554 while (gotent
->gotobj
!= gotobj
|| gotent
->addend
!= addend
)
3555 gotent
= gotent
->next
;
3557 BFD_ASSERT(gotent
->use_count
>= 1);
3559 /* Initialize the .got entry's value. */
3560 if (!(gotent
->flags
& ALPHA_ELF_GOT_ENTRY_RELOCS_DONE
))
3562 bfd_put_64 (output_bfd
, relocation
+addend
,
3563 sgot
->contents
+ gotent
->got_offset
);
3565 /* If the symbol has been forced local, output a
3566 RELATIVE reloc, otherwise it will be handled in
3567 finish_dynamic_symbol. */
3568 if (info
->shared
&& !dynamic_symbol
)
3570 Elf_Internal_Rela outrel
;
3572 BFD_ASSERT(srelgot
!= NULL
);
3574 outrel
.r_offset
= (sgot
->output_section
->vma
3575 + sgot
->output_offset
3576 + gotent
->got_offset
);
3577 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
3578 outrel
.r_addend
= 0;
3580 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3581 ((Elf64_External_Rela
*)
3583 + srelgot
->reloc_count
++);
3584 BFD_ASSERT (sizeof (Elf64_External_Rela
)
3585 * srelgot
->reloc_count
3586 <= srelgot
->_cooked_size
);
3589 gotent
->flags
|= ALPHA_ELF_GOT_ENTRY_RELOCS_DONE
;
3592 /* Figure the gprel relocation. */
3594 relocation
= (sgot
->output_section
->vma
3595 + sgot
->output_offset
3596 + gotent
->got_offset
);
3599 /* overflow handled by _bfd_final_link_relocate */
3602 case R_ALPHA_GPREL32
:
3603 case R_ALPHA_GPRELLOW
:
3604 BFD_ASSERT(gp
!= 0);
3608 case R_ALPHA_GPRELHIGH
:
3609 BFD_ASSERT(gp
!= 0);
3611 relocation
+= addend
;
3613 relocation
= (((bfd_signed_vma
) relocation
>> 16)
3614 + ((relocation
>> 15) & 1));
3617 case R_ALPHA_BRADDR
:
3619 /* The regular PC-relative stuff measures from the start of
3620 the instruction rather than the end. */
3624 case R_ALPHA_REFLONG
:
3625 case R_ALPHA_REFQUAD
:
3627 Elf_Internal_Rela outrel
;
3630 /* Careful here to remember RELATIVE relocations for global
3631 variables for symbolic shared objects. */
3633 if (h
&& alpha_elf_dynamic_symbol_p (&h
->root
, info
))
3635 BFD_ASSERT(h
->root
.dynindx
!= -1);
3636 outrel
.r_info
= ELF64_R_INFO(h
->root
.dynindx
, r_type
);
3637 outrel
.r_addend
= addend
;
3638 addend
= 0, relocation
= 0;
3640 else if (info
->shared
&& (input_section
->flags
& SEC_ALLOC
))
3642 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
3643 outrel
.r_addend
= 0;
3652 name
= (bfd_elf_string_from_elf_section
3653 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
3654 elf_section_data(input_section
)->rel_hdr
.sh_name
));
3655 BFD_ASSERT(name
!= NULL
);
3657 srel
= bfd_get_section_by_name (dynobj
, name
);
3658 BFD_ASSERT(srel
!= NULL
);
3663 if (elf_section_data (input_section
)->stab_info
== NULL
)
3664 outrel
.r_offset
= rel
->r_offset
;
3669 off
= (_bfd_stab_section_offset
3670 (output_bfd
, &elf_hash_table (info
)->stab_info
,
3672 &elf_section_data (input_section
)->stab_info
,
3674 if (off
== (bfd_vma
) -1)
3676 outrel
.r_offset
= off
;
3680 outrel
.r_offset
+= (input_section
->output_section
->vma
3681 + input_section
->output_offset
);
3683 memset (&outrel
, 0, sizeof outrel
);
3685 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3686 ((Elf64_External_Rela
*)
3688 + srel
->reloc_count
++);
3689 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
3690 <= srel
->_cooked_size
);
3696 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
3697 contents
, rel
->r_offset
, relocation
,
3707 case bfd_reloc_overflow
:
3712 name
= h
->root
.root
.root
.string
;
3715 name
= (bfd_elf_string_from_elf_section
3716 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
3720 name
= bfd_section_name (input_bfd
, sec
);
3722 if (! ((*info
->callbacks
->reloc_overflow
)
3723 (info
, name
, howto
->name
, (bfd_vma
) 0,
3724 input_bfd
, input_section
, rel
->r_offset
)))
3730 case bfd_reloc_outofrange
:
3738 /* Finish up dynamic symbol handling. We set the contents of various
3739 dynamic sections here. */
3742 elf64_alpha_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3744 struct bfd_link_info
*info
;
3745 struct elf_link_hash_entry
*h
;
3746 Elf_Internal_Sym
*sym
;
3748 bfd
*dynobj
= elf_hash_table(info
)->dynobj
;
3750 if (h
->plt
.offset
!= MINUS_ONE
)
3752 /* Fill in the .plt entry for this symbol. */
3753 asection
*splt
, *sgot
, *srel
;
3754 Elf_Internal_Rela outrel
;
3755 bfd_vma got_addr
, plt_addr
;
3757 struct alpha_elf_got_entry
*gotent
;
3759 BFD_ASSERT (h
->dynindx
!= -1);
3761 /* The first .got entry will be updated by the .plt with the
3762 address of the target function. */
3763 gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
3764 BFD_ASSERT (gotent
&& gotent
->addend
== 0);
3766 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3767 BFD_ASSERT (splt
!= NULL
);
3768 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
3769 BFD_ASSERT (srel
!= NULL
);
3770 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
3771 BFD_ASSERT (sgot
!= NULL
);
3773 got_addr
= (sgot
->output_section
->vma
3774 + sgot
->output_offset
3775 + gotent
->got_offset
);
3776 plt_addr
= (splt
->output_section
->vma
3777 + splt
->output_offset
3780 plt_index
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
3782 /* Fill in the entry in the procedure linkage table. */
3784 unsigned insn1
, insn2
, insn3
;
3786 insn1
= PLT_ENTRY_WORD1
| ((-(h
->plt
.offset
+ 4) >> 2) & 0x1fffff);
3787 insn2
= PLT_ENTRY_WORD2
;
3788 insn3
= PLT_ENTRY_WORD3
;
3790 bfd_put_32 (output_bfd
, insn1
, splt
->contents
+ h
->plt
.offset
);
3791 bfd_put_32 (output_bfd
, insn2
, splt
->contents
+ h
->plt
.offset
+ 4);
3792 bfd_put_32 (output_bfd
, insn3
, splt
->contents
+ h
->plt
.offset
+ 8);
3795 /* Fill in the entry in the .rela.plt section. */
3796 outrel
.r_offset
= got_addr
;
3797 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
3798 outrel
.r_addend
= 0;
3800 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3801 ((Elf64_External_Rela
*)srel
->contents
3804 if (!(h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
3806 /* Mark the symbol as undefined, rather than as defined in the
3807 .plt section. Leave the value alone. */
3808 sym
->st_shndx
= SHN_UNDEF
;
3811 /* Fill in the entries in the .got. */
3812 bfd_put_64 (output_bfd
, plt_addr
, sgot
->contents
+ gotent
->got_offset
);
3814 /* Subsequent .got entries will continue to bounce through the .plt. */
3817 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3818 BFD_ASSERT (! info
->shared
|| srel
!= NULL
);
3820 gotent
= gotent
->next
;
3823 sgot
= alpha_elf_tdata(gotent
->gotobj
)->got
;
3824 BFD_ASSERT(sgot
!= NULL
);
3825 BFD_ASSERT(gotent
->addend
== 0);
3827 bfd_put_64 (output_bfd
, plt_addr
,
3828 sgot
->contents
+ gotent
->got_offset
);
3832 outrel
.r_offset
= (sgot
->output_section
->vma
3833 + sgot
->output_offset
3834 + gotent
->got_offset
);
3835 outrel
.r_info
= ELF64_R_INFO(0, R_ALPHA_RELATIVE
);
3836 outrel
.r_addend
= 0;
3838 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3839 ((Elf64_External_Rela
*)
3841 + srel
->reloc_count
++);
3842 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
3843 <= srel
->_cooked_size
);
3846 gotent
= gotent
->next
;
3848 while (gotent
!= NULL
);
3851 else if (alpha_elf_dynamic_symbol_p (h
, info
))
3853 /* Fill in the dynamic relocations for this symbol's .got entries. */
3855 Elf_Internal_Rela outrel
;
3856 struct alpha_elf_got_entry
*gotent
;
3858 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
3859 BFD_ASSERT (srel
!= NULL
);
3861 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_ALPHA_GLOB_DAT
);
3862 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
3864 gotent
= gotent
->next
)
3866 asection
*sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
3867 outrel
.r_offset
= (sgot
->output_section
->vma
3868 + sgot
->output_offset
3869 + gotent
->got_offset
);
3870 outrel
.r_addend
= gotent
->addend
;
3872 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
,
3873 ((Elf64_External_Rela
*)srel
->contents
3874 + srel
->reloc_count
++));
3875 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
3876 <= srel
->_cooked_size
);
3880 /* Mark some specially defined symbols as absolute. */
3881 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3882 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3883 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3884 sym
->st_shndx
= SHN_ABS
;
3889 /* Finish up the dynamic sections. */
3892 elf64_alpha_finish_dynamic_sections (output_bfd
, info
)
3894 struct bfd_link_info
*info
;
3899 dynobj
= elf_hash_table (info
)->dynobj
;
3900 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3902 if (elf_hash_table (info
)->dynamic_sections_created
)
3905 Elf64_External_Dyn
*dyncon
, *dynconend
;
3907 splt
= bfd_get_section_by_name (dynobj
, ".plt");
3908 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3910 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3911 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3912 for (; dyncon
< dynconend
; dyncon
++)
3914 Elf_Internal_Dyn dyn
;
3918 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3933 /* My interpretation of the TIS v1.1 ELF document indicates
3934 that RELASZ should not include JMPREL. This is not what
3935 the rest of the BFD does. It is, however, what the
3936 glibc ld.so wants. Do this fixup here until we found
3937 out who is right. */
3938 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
3942 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
3947 s
= bfd_get_section_by_name (output_bfd
, name
);
3948 dyn
.d_un
.d_ptr
= (s
? s
->vma
: 0);
3952 s
= bfd_get_section_by_name (output_bfd
, name
);
3954 (s
->_cooked_size
? s
->_cooked_size
: s
->_raw_size
);
3958 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3961 /* Initialize the PLT0 entry */
3962 if (splt
->_raw_size
> 0)
3964 bfd_put_32 (output_bfd
, PLT_HEADER_WORD1
, splt
->contents
);
3965 bfd_put_32 (output_bfd
, PLT_HEADER_WORD2
, splt
->contents
+ 4);
3966 bfd_put_32 (output_bfd
, PLT_HEADER_WORD3
, splt
->contents
+ 8);
3967 bfd_put_32 (output_bfd
, PLT_HEADER_WORD4
, splt
->contents
+ 12);
3969 /* The next two words will be filled in by ld.so */
3970 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 16);
3971 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 24);
3973 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
=
3981 /* We need to use a special link routine to handle the .reginfo and
3982 the .mdebug sections. We need to merge all instances of these
3983 sections together, not write them all out sequentially. */
3986 elf64_alpha_final_link (abfd
, info
)
3988 struct bfd_link_info
*info
;
3991 struct bfd_link_order
*p
;
3992 asection
*reginfo_sec
, *mdebug_sec
, *gptab_data_sec
, *gptab_bss_sec
;
3993 struct ecoff_debug_info debug
;
3994 const struct ecoff_debug_swap
*swap
3995 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
3996 HDRR
*symhdr
= &debug
.symbolic_header
;
3997 PTR mdebug_handle
= NULL
;
4002 (*info
->callbacks
->warning
)
4003 (info
, _("using multiple gp values"), (char *) NULL
,
4004 output_bfd
, (asection
*) NULL
, (bfd_vma
) 0);
4008 /* Go through the sections and collect the .reginfo and .mdebug
4012 gptab_data_sec
= NULL
;
4013 gptab_bss_sec
= NULL
;
4014 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
4016 #ifdef ERIC_neverdef
4017 if (strcmp (o
->name
, ".reginfo") == 0)
4019 memset (®info
, 0, sizeof reginfo
);
4021 /* We have found the .reginfo section in the output file.
4022 Look through all the link_orders comprising it and merge
4023 the information together. */
4024 for (p
= o
->link_order_head
;
4025 p
!= (struct bfd_link_order
*) NULL
;
4028 asection
*input_section
;
4030 Elf64_External_RegInfo ext
;
4033 if (p
->type
!= bfd_indirect_link_order
)
4035 if (p
->type
== bfd_fill_link_order
)
4040 input_section
= p
->u
.indirect
.section
;
4041 input_bfd
= input_section
->owner
;
4043 /* The linker emulation code has probably clobbered the
4044 size to be zero bytes. */
4045 if (input_section
->_raw_size
== 0)
4046 input_section
->_raw_size
= sizeof (Elf64_External_RegInfo
);
4048 if (! bfd_get_section_contents (input_bfd
, input_section
,
4054 bfd_alpha_elf64_swap_reginfo_in (input_bfd
, &ext
, &sub
);
4056 reginfo
.ri_gprmask
|= sub
.ri_gprmask
;
4057 reginfo
.ri_cprmask
[0] |= sub
.ri_cprmask
[0];
4058 reginfo
.ri_cprmask
[1] |= sub
.ri_cprmask
[1];
4059 reginfo
.ri_cprmask
[2] |= sub
.ri_cprmask
[2];
4060 reginfo
.ri_cprmask
[3] |= sub
.ri_cprmask
[3];
4062 /* ri_gp_value is set by the function
4063 alpha_elf_section_processing when the section is
4064 finally written out. */
4066 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4067 elf_link_input_bfd ignores this section. */
4068 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4071 /* Force the section size to the value we want. */
4072 o
->_raw_size
= sizeof (Elf64_External_RegInfo
);
4074 /* Skip this section later on (I don't think this currently
4075 matters, but someday it might). */
4076 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4082 if (strcmp (o
->name
, ".mdebug") == 0)
4084 struct extsym_info einfo
;
4086 /* We have found the .mdebug section in the output file.
4087 Look through all the link_orders comprising it and merge
4088 the information together. */
4089 symhdr
->magic
= swap
->sym_magic
;
4090 /* FIXME: What should the version stamp be? */
4092 symhdr
->ilineMax
= 0;
4096 symhdr
->isymMax
= 0;
4097 symhdr
->ioptMax
= 0;
4098 symhdr
->iauxMax
= 0;
4100 symhdr
->issExtMax
= 0;
4103 symhdr
->iextMax
= 0;
4105 /* We accumulate the debugging information itself in the
4106 debug_info structure. */
4108 debug
.external_dnr
= NULL
;
4109 debug
.external_pdr
= NULL
;
4110 debug
.external_sym
= NULL
;
4111 debug
.external_opt
= NULL
;
4112 debug
.external_aux
= NULL
;
4114 debug
.ssext
= debug
.ssext_end
= NULL
;
4115 debug
.external_fdr
= NULL
;
4116 debug
.external_rfd
= NULL
;
4117 debug
.external_ext
= debug
.external_ext_end
= NULL
;
4119 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
4120 if (mdebug_handle
== (PTR
) NULL
)
4129 static const char * const name
[] =
4131 ".text", ".init", ".fini", ".data",
4132 ".rodata", ".sdata", ".sbss", ".bss"
4134 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
4135 scRData
, scSData
, scSBss
, scBss
};
4138 esym
.cobol_main
= 0;
4142 esym
.asym
.iss
= issNil
;
4143 esym
.asym
.st
= stLocal
;
4144 esym
.asym
.reserved
= 0;
4145 esym
.asym
.index
= indexNil
;
4146 for (i
= 0; i
< 8; i
++)
4148 esym
.asym
.sc
= sc
[i
];
4149 s
= bfd_get_section_by_name (abfd
, name
[i
]);
4152 esym
.asym
.value
= s
->vma
;
4153 last
= s
->vma
+ s
->_raw_size
;
4156 esym
.asym
.value
= last
;
4158 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
4164 for (p
= o
->link_order_head
;
4165 p
!= (struct bfd_link_order
*) NULL
;
4168 asection
*input_section
;
4170 const struct ecoff_debug_swap
*input_swap
;
4171 struct ecoff_debug_info input_debug
;
4175 if (p
->type
!= bfd_indirect_link_order
)
4177 if (p
->type
== bfd_fill_link_order
)
4182 input_section
= p
->u
.indirect
.section
;
4183 input_bfd
= input_section
->owner
;
4185 if (bfd_get_flavour (input_bfd
) != bfd_target_elf_flavour
4186 || (get_elf_backend_data (input_bfd
)
4187 ->elf_backend_ecoff_debug_swap
) == NULL
)
4189 /* I don't know what a non ALPHA ELF bfd would be
4190 doing with a .mdebug section, but I don't really
4191 want to deal with it. */
4195 input_swap
= (get_elf_backend_data (input_bfd
)
4196 ->elf_backend_ecoff_debug_swap
);
4198 BFD_ASSERT (p
->size
== input_section
->_raw_size
);
4200 /* The ECOFF linking code expects that we have already
4201 read in the debugging information and set up an
4202 ecoff_debug_info structure, so we do that now. */
4203 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
4207 if (! (bfd_ecoff_debug_accumulate
4208 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
4209 &input_debug
, input_swap
, info
)))
4212 /* Loop through the external symbols. For each one with
4213 interesting information, try to find the symbol in
4214 the linker global hash table and save the information
4215 for the output external symbols. */
4216 eraw_src
= input_debug
.external_ext
;
4217 eraw_end
= (eraw_src
4218 + (input_debug
.symbolic_header
.iextMax
4219 * input_swap
->external_ext_size
));
4221 eraw_src
< eraw_end
;
4222 eraw_src
+= input_swap
->external_ext_size
)
4226 struct alpha_elf_link_hash_entry
*h
;
4228 (*input_swap
->swap_ext_in
) (input_bfd
, (PTR
) eraw_src
, &ext
);
4229 if (ext
.asym
.sc
== scNil
4230 || ext
.asym
.sc
== scUndefined
4231 || ext
.asym
.sc
== scSUndefined
)
4234 name
= input_debug
.ssext
+ ext
.asym
.iss
;
4235 h
= alpha_elf_link_hash_lookup (alpha_elf_hash_table (info
),
4236 name
, false, false, true);
4237 if (h
== NULL
|| h
->esym
.ifd
!= -2)
4243 < input_debug
.symbolic_header
.ifdMax
);
4244 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
4250 /* Free up the information we just read. */
4251 free (input_debug
.line
);
4252 free (input_debug
.external_dnr
);
4253 free (input_debug
.external_pdr
);
4254 free (input_debug
.external_sym
);
4255 free (input_debug
.external_opt
);
4256 free (input_debug
.external_aux
);
4257 free (input_debug
.ss
);
4258 free (input_debug
.ssext
);
4259 free (input_debug
.external_fdr
);
4260 free (input_debug
.external_rfd
);
4261 free (input_debug
.external_ext
);
4263 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4264 elf_link_input_bfd ignores this section. */
4265 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4268 #ifdef ERIC_neverdef
4271 /* Create .rtproc section. */
4272 rtproc_sec
= bfd_get_section_by_name (abfd
, ".rtproc");
4273 if (rtproc_sec
== NULL
)
4275 flagword flags
= (SEC_HAS_CONTENTS
4277 | SEC_LINKER_CREATED
4280 rtproc_sec
= bfd_make_section (abfd
, ".rtproc");
4281 if (rtproc_sec
== NULL
4282 || ! bfd_set_section_flags (abfd
, rtproc_sec
, flags
)
4283 || ! bfd_set_section_alignment (abfd
, rtproc_sec
, 12))
4287 if (! alpha_elf_create_procedure_table (mdebug_handle
, abfd
,
4288 info
, rtproc_sec
, &debug
))
4293 /* Build the external symbol information. */
4296 einfo
.debug
= &debug
;
4298 einfo
.failed
= false;
4299 elf_link_hash_traverse (elf_hash_table (info
),
4300 elf64_alpha_output_extsym
,
4305 /* Set the size of the .mdebug section. */
4306 o
->_raw_size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
4308 /* Skip this section later on (I don't think this currently
4309 matters, but someday it might). */
4310 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4315 #ifdef ERIC_neverdef
4316 if (strncmp (o
->name
, ".gptab.", sizeof ".gptab." - 1) == 0)
4318 const char *subname
;
4321 Elf64_External_gptab
*ext_tab
;
4324 /* The .gptab.sdata and .gptab.sbss sections hold
4325 information describing how the small data area would
4326 change depending upon the -G switch. These sections
4327 not used in executables files. */
4328 if (! info
->relocateable
)
4332 for (p
= o
->link_order_head
;
4333 p
!= (struct bfd_link_order
*) NULL
;
4336 asection
*input_section
;
4338 if (p
->type
!= bfd_indirect_link_order
)
4340 if (p
->type
== bfd_fill_link_order
)
4345 input_section
= p
->u
.indirect
.section
;
4347 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4348 elf_link_input_bfd ignores this section. */
4349 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4352 /* Skip this section later on (I don't think this
4353 currently matters, but someday it might). */
4354 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4356 /* Really remove the section. */
4357 for (secpp
= &abfd
->sections
;
4359 secpp
= &(*secpp
)->next
)
4361 *secpp
= (*secpp
)->next
;
4362 --abfd
->section_count
;
4367 /* There is one gptab for initialized data, and one for
4368 uninitialized data. */
4369 if (strcmp (o
->name
, ".gptab.sdata") == 0)
4371 else if (strcmp (o
->name
, ".gptab.sbss") == 0)
4375 (*_bfd_error_handler
)
4376 (_("%s: illegal section name `%s'"),
4377 bfd_get_filename (abfd
), o
->name
);
4378 bfd_set_error (bfd_error_nonrepresentable_section
);
4382 /* The linker script always combines .gptab.data and
4383 .gptab.sdata into .gptab.sdata, and likewise for
4384 .gptab.bss and .gptab.sbss. It is possible that there is
4385 no .sdata or .sbss section in the output file, in which
4386 case we must change the name of the output section. */
4387 subname
= o
->name
+ sizeof ".gptab" - 1;
4388 if (bfd_get_section_by_name (abfd
, subname
) == NULL
)
4390 if (o
== gptab_data_sec
)
4391 o
->name
= ".gptab.data";
4393 o
->name
= ".gptab.bss";
4394 subname
= o
->name
+ sizeof ".gptab" - 1;
4395 BFD_ASSERT (bfd_get_section_by_name (abfd
, subname
) != NULL
);
4398 /* Set up the first entry. */
4400 tab
= (Elf64_gptab
*) bfd_malloc (c
* sizeof (Elf64_gptab
));
4403 tab
[0].gt_header
.gt_current_g_value
= elf_gp_size (abfd
);
4404 tab
[0].gt_header
.gt_unused
= 0;
4406 /* Combine the input sections. */
4407 for (p
= o
->link_order_head
;
4408 p
!= (struct bfd_link_order
*) NULL
;
4411 asection
*input_section
;
4415 bfd_size_type gpentry
;
4417 if (p
->type
!= bfd_indirect_link_order
)
4419 if (p
->type
== bfd_fill_link_order
)
4424 input_section
= p
->u
.indirect
.section
;
4425 input_bfd
= input_section
->owner
;
4427 /* Combine the gptab entries for this input section one
4428 by one. We know that the input gptab entries are
4429 sorted by ascending -G value. */
4430 size
= bfd_section_size (input_bfd
, input_section
);
4432 for (gpentry
= sizeof (Elf64_External_gptab
);
4434 gpentry
+= sizeof (Elf64_External_gptab
))
4436 Elf64_External_gptab ext_gptab
;
4437 Elf64_gptab int_gptab
;
4443 if (! (bfd_get_section_contents
4444 (input_bfd
, input_section
, (PTR
) &ext_gptab
,
4445 gpentry
, sizeof (Elf64_External_gptab
))))
4451 bfd_alpha_elf64_swap_gptab_in (input_bfd
, &ext_gptab
,
4453 val
= int_gptab
.gt_entry
.gt_g_value
;
4454 add
= int_gptab
.gt_entry
.gt_bytes
- last
;
4457 for (look
= 1; look
< c
; look
++)
4459 if (tab
[look
].gt_entry
.gt_g_value
>= val
)
4460 tab
[look
].gt_entry
.gt_bytes
+= add
;
4462 if (tab
[look
].gt_entry
.gt_g_value
== val
)
4468 Elf64_gptab
*new_tab
;
4471 /* We need a new table entry. */
4472 new_tab
= ((Elf64_gptab
*)
4473 bfd_realloc ((PTR
) tab
,
4474 (c
+ 1) * sizeof (Elf64_gptab
)));
4475 if (new_tab
== NULL
)
4481 tab
[c
].gt_entry
.gt_g_value
= val
;
4482 tab
[c
].gt_entry
.gt_bytes
= add
;
4484 /* Merge in the size for the next smallest -G
4485 value, since that will be implied by this new
4488 for (look
= 1; look
< c
; look
++)
4490 if (tab
[look
].gt_entry
.gt_g_value
< val
4492 || (tab
[look
].gt_entry
.gt_g_value
4493 > tab
[max
].gt_entry
.gt_g_value
)))
4497 tab
[c
].gt_entry
.gt_bytes
+=
4498 tab
[max
].gt_entry
.gt_bytes
;
4503 last
= int_gptab
.gt_entry
.gt_bytes
;
4506 /* Hack: reset the SEC_HAS_CONTENTS flag so that
4507 elf_link_input_bfd ignores this section. */
4508 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
4511 /* The table must be sorted by -G value. */
4513 qsort (tab
+ 1, c
- 1, sizeof (tab
[0]), gptab_compare
);
4515 /* Swap out the table. */
4516 ext_tab
= ((Elf64_External_gptab
*)
4517 bfd_alloc (abfd
, c
* sizeof (Elf64_External_gptab
)));
4518 if (ext_tab
== NULL
)
4524 for (i
= 0; i
< c
; i
++)
4525 bfd_alpha_elf64_swap_gptab_out (abfd
, tab
+ i
, ext_tab
+ i
);
4528 o
->_raw_size
= c
* sizeof (Elf64_External_gptab
);
4529 o
->contents
= (bfd_byte
*) ext_tab
;
4531 /* Skip this section later on (I don't think this currently
4532 matters, but someday it might). */
4533 o
->link_order_head
= (struct bfd_link_order
*) NULL
;
4539 /* Invoke the regular ELF backend linker to do all the work. */
4540 if (! bfd_elf64_bfd_final_link (abfd
, info
))
4543 /* Now write out the computed sections. */
4545 /* The .got subsections... */
4547 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
4548 for (i
= alpha_elf_hash_table(info
)->got_list
;
4550 i
= alpha_elf_tdata(i
)->got_link_next
)
4554 /* elf_bfd_final_link already did everything in dynobj. */
4558 sgot
= alpha_elf_tdata(i
)->got
;
4559 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
4560 sgot
->contents
, sgot
->output_offset
,
4566 #ifdef ERIC_neverdef
4567 if (reginfo_sec
!= (asection
*) NULL
)
4569 Elf64_External_RegInfo ext
;
4571 bfd_alpha_elf64_swap_reginfo_out (abfd
, ®info
, &ext
);
4572 if (! bfd_set_section_contents (abfd
, reginfo_sec
, (PTR
) &ext
,
4573 (file_ptr
) 0, sizeof ext
))
4578 if (mdebug_sec
!= (asection
*) NULL
)
4580 BFD_ASSERT (abfd
->output_has_begun
);
4581 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
4583 mdebug_sec
->filepos
))
4586 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
4589 if (gptab_data_sec
!= (asection
*) NULL
)
4591 if (! bfd_set_section_contents (abfd
, gptab_data_sec
,
4592 gptab_data_sec
->contents
,
4594 gptab_data_sec
->_raw_size
))
4598 if (gptab_bss_sec
!= (asection
*) NULL
)
4600 if (! bfd_set_section_contents (abfd
, gptab_bss_sec
,
4601 gptab_bss_sec
->contents
,
4603 gptab_bss_sec
->_raw_size
))
4610 /* ECOFF swapping routines. These are used when dealing with the
4611 .mdebug section, which is in the ECOFF debugging format. Copied
4612 from elf32-mips.c. */
4613 static const struct ecoff_debug_swap
4614 elf64_alpha_ecoff_debug_swap
=
4616 /* Symbol table magic number. */
4618 /* Alignment of debugging information. E.g., 4. */
4620 /* Sizes of external symbolic information. */
4621 sizeof (struct hdr_ext
),
4622 sizeof (struct dnr_ext
),
4623 sizeof (struct pdr_ext
),
4624 sizeof (struct sym_ext
),
4625 sizeof (struct opt_ext
),
4626 sizeof (struct fdr_ext
),
4627 sizeof (struct rfd_ext
),
4628 sizeof (struct ext_ext
),
4629 /* Functions to swap in external symbolic data. */
4638 _bfd_ecoff_swap_tir_in
,
4639 _bfd_ecoff_swap_rndx_in
,
4640 /* Functions to swap out external symbolic data. */
4649 _bfd_ecoff_swap_tir_out
,
4650 _bfd_ecoff_swap_rndx_out
,
4651 /* Function to read in symbolic data. */
4652 elf64_alpha_read_ecoff_info
4655 /* Use a non-standard hash bucket size of 8. */
4657 const struct elf_size_info alpha_elf_size_info
=
4659 sizeof (Elf64_External_Ehdr
),
4660 sizeof (Elf64_External_Phdr
),
4661 sizeof (Elf64_External_Shdr
),
4662 sizeof (Elf64_External_Rel
),
4663 sizeof (Elf64_External_Rela
),
4664 sizeof (Elf64_External_Sym
),
4665 sizeof (Elf64_External_Dyn
),
4666 sizeof (Elf_External_Note
),
4670 ELFCLASS64
, EV_CURRENT
,
4671 bfd_elf64_write_out_phdrs
,
4672 bfd_elf64_write_shdrs_and_ehdr
,
4673 bfd_elf64_write_relocs
,
4674 bfd_elf64_swap_symbol_out
,
4675 bfd_elf64_slurp_reloc_table
,
4676 bfd_elf64_slurp_symbol_table
,
4677 bfd_elf64_swap_dyn_in
,
4678 bfd_elf64_swap_dyn_out
,
4685 #define TARGET_LITTLE_SYM bfd_elf64_alpha_vec
4686 #define TARGET_LITTLE_NAME "elf64-alpha"
4687 #define ELF_ARCH bfd_arch_alpha
4688 #define ELF_MACHINE_CODE EM_ALPHA
4689 #define ELF_MAXPAGESIZE 0x10000
4691 #define bfd_elf64_bfd_link_hash_table_create \
4692 elf64_alpha_bfd_link_hash_table_create
4694 #define bfd_elf64_bfd_reloc_type_lookup \
4695 elf64_alpha_bfd_reloc_type_lookup
4696 #define elf_info_to_howto \
4697 elf64_alpha_info_to_howto
4699 #define bfd_elf64_mkobject \
4700 elf64_alpha_mkobject
4701 #define elf_backend_object_p \
4702 elf64_alpha_object_p
4704 #define elf_backend_section_from_shdr \
4705 elf64_alpha_section_from_shdr
4706 #define elf_backend_fake_sections \
4707 elf64_alpha_fake_sections
4709 #define bfd_elf64_bfd_is_local_label_name \
4710 elf64_alpha_is_local_label_name
4711 #define bfd_elf64_find_nearest_line \
4712 elf64_alpha_find_nearest_line
4713 #define bfd_elf64_bfd_relax_section \
4714 elf64_alpha_relax_section
4716 #define elf_backend_add_symbol_hook \
4717 elf64_alpha_add_symbol_hook
4718 #define elf_backend_check_relocs \
4719 elf64_alpha_check_relocs
4720 #define elf_backend_create_dynamic_sections \
4721 elf64_alpha_create_dynamic_sections
4722 #define elf_backend_adjust_dynamic_symbol \
4723 elf64_alpha_adjust_dynamic_symbol
4724 #define elf_backend_always_size_sections \
4725 elf64_alpha_always_size_sections
4726 #define elf_backend_size_dynamic_sections \
4727 elf64_alpha_size_dynamic_sections
4728 #define elf_backend_relocate_section \
4729 elf64_alpha_relocate_section
4730 #define elf_backend_finish_dynamic_symbol \
4731 elf64_alpha_finish_dynamic_symbol
4732 #define elf_backend_finish_dynamic_sections \
4733 elf64_alpha_finish_dynamic_sections
4734 #define bfd_elf64_bfd_final_link \
4735 elf64_alpha_final_link
4737 #define elf_backend_ecoff_debug_swap \
4738 &elf64_alpha_ecoff_debug_swap
4740 #define elf_backend_size_info \
4743 /* A few constants that determine how the .plt section is set up. */
4744 #define elf_backend_want_got_plt 0
4745 #define elf_backend_plt_readonly 0
4746 #define elf_backend_want_plt_sym 1
4747 #define elf_backend_got_header_size 0
4748 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4750 #include "elf64-target.h"