1 /* Alpha specific support for 64-bit ELF
2 Copyright (C) 1996-2021 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* We need a published ABI spec for this. Until one comes out, don't
24 assume this'll remain unchanged forever. */
30 #include "ecoff-bfd.h"
32 #include "elf/alpha.h"
36 #define NO_COFF_RELOCS
37 #define NO_COFF_SYMBOLS
38 #define NO_COFF_LINENOS
40 /* Get the ECOFF swapping routines. Needed for the debug information. */
41 #include "coff/internal.h"
43 #include "coff/symconst.h"
44 #include "coff/ecoff.h"
45 #include "coff/alpha.h"
50 #include "ecoffswap.h"
53 /* Instruction data for plt generation and relaxation. */
61 #define INSN_LDA (OP_LDA << 26)
62 #define INSN_LDAH (OP_LDAH << 26)
63 #define INSN_LDQ (OP_LDQ << 26)
64 #define INSN_BR (OP_BR << 26)
66 #define INSN_ADDQ 0x40000400
67 #define INSN_RDUNIQ 0x0000009e
68 #define INSN_SUBQ 0x40000520
69 #define INSN_S4SUBQ 0x40000560
70 #define INSN_UNOP 0x2ffe0000
72 #define INSN_JSR 0x68004000
73 #define INSN_JMP 0x68000000
74 #define INSN_JSR_MASK 0xfc00c000
76 #define INSN_A(I,A) (I | ((unsigned) A << 21))
77 #define INSN_AB(I,A,B) (INSN_A (I, A) | (B << 16))
78 #define INSN_ABC(I,A,B,C) (INSN_A (I, A) | (B << 16) | C)
79 #define INSN_ABO(I,A,B,O) (INSN_A (I, A) | (B << 16) | ((O) & 0xffff))
80 #define INSN_AD(I,A,D) (INSN_A (I, A) | (((D) >> 2) & 0x1fffff))
84 /* Set by ld emulation. Putting this into the link_info or hash structure
85 is simply working too hard. */
87 bool elf64_alpha_use_secureplt
= true;
89 bool elf64_alpha_use_secureplt
= false;
92 #define OLD_PLT_HEADER_SIZE 32
93 #define OLD_PLT_ENTRY_SIZE 12
94 #define NEW_PLT_HEADER_SIZE 36
95 #define NEW_PLT_ENTRY_SIZE 4
97 #define PLT_HEADER_SIZE \
98 (elf64_alpha_use_secureplt ? NEW_PLT_HEADER_SIZE : OLD_PLT_HEADER_SIZE)
99 #define PLT_ENTRY_SIZE \
100 (elf64_alpha_use_secureplt ? NEW_PLT_ENTRY_SIZE : OLD_PLT_ENTRY_SIZE)
102 #define MAX_GOT_SIZE (64*1024)
104 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
107 /* Used to implement multiple .got subsections. */
108 struct alpha_elf_got_entry
110 struct alpha_elf_got_entry
*next
;
112 /* Which .got subsection? */
115 /* The addend in effect for this entry. */
118 /* The .got offset for this entry. */
121 /* The .plt offset for this entry. */
124 /* How many references to this entry? */
127 /* The relocation type of this entry. */
128 unsigned char reloc_type
;
130 /* How a LITERAL is used. */
133 /* Have we initialized the dynamic relocation for this entry? */
134 unsigned char reloc_done
;
136 /* Have we adjusted this entry for SEC_MERGE? */
137 unsigned char reloc_xlated
;
140 struct alpha_elf_reloc_entry
142 struct alpha_elf_reloc_entry
*next
;
144 /* Which .reloc section? */
147 /* Which section this relocation is against? */
150 /* How many did we find? */
153 /* What kind of relocation? */
157 struct alpha_elf_link_hash_entry
159 struct elf_link_hash_entry root
;
161 /* External symbol information. */
164 /* Cumulative flags for all the .got entries. */
167 /* Contexts in which a literal was referenced. */
168 #define ALPHA_ELF_LINK_HASH_LU_ADDR 0x01
169 #define ALPHA_ELF_LINK_HASH_LU_MEM 0x02
170 #define ALPHA_ELF_LINK_HASH_LU_BYTE 0x04
171 #define ALPHA_ELF_LINK_HASH_LU_JSR 0x08
172 #define ALPHA_ELF_LINK_HASH_LU_TLSGD 0x10
173 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM 0x20
174 #define ALPHA_ELF_LINK_HASH_LU_JSRDIRECT 0x40
175 #define ALPHA_ELF_LINK_HASH_LU_PLT 0x38
176 #define ALPHA_ELF_LINK_HASH_TLS_IE 0x80
178 /* Used to implement multiple .got subsections. */
179 struct alpha_elf_got_entry
*got_entries
;
181 /* Used to count non-got, non-plt relocations for delayed sizing
182 of relocation sections. */
183 struct alpha_elf_reloc_entry
*reloc_entries
;
186 /* Alpha ELF linker hash table. */
188 struct alpha_elf_link_hash_table
190 struct elf_link_hash_table root
;
192 /* The head of a list of .got subsections linked through
193 alpha_elf_tdata(abfd)->got_link_next. */
196 /* The most recent relax pass that we've seen. The GOTs
197 should be regenerated if this doesn't match. */
201 /* Look up an entry in a Alpha ELF linker hash table. */
203 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
204 ((struct alpha_elf_link_hash_entry *) \
205 elf_link_hash_lookup (&(table)->root, (string), (create), \
208 /* Traverse a Alpha ELF linker hash table. */
210 #define alpha_elf_link_hash_traverse(table, func, info) \
211 (elf_link_hash_traverse \
213 (bool (*) (struct elf_link_hash_entry *, void *)) (func), \
216 /* Get the Alpha ELF linker hash table from a link_info structure. */
218 #define alpha_elf_hash_table(p) \
219 ((is_elf_hash_table ((p)->hash) \
220 && elf_hash_table_id (elf_hash_table (p)) == ALPHA_ELF_DATA) \
221 ? (struct alpha_elf_link_hash_table *) (p)->hash : NULL)
223 /* Get the object's symbols as our own entry type. */
225 #define alpha_elf_sym_hashes(abfd) \
226 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
228 /* Should we do dynamic things to this symbol? This differs from the
229 generic version in that we never need to consider function pointer
230 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
231 address is ever taken. */
234 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
235 struct bfd_link_info
*info
)
237 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
240 /* Create an entry in a Alpha ELF linker hash table. */
242 static struct bfd_hash_entry
*
243 elf64_alpha_link_hash_newfunc (struct bfd_hash_entry
*entry
,
244 struct bfd_hash_table
*table
,
247 struct alpha_elf_link_hash_entry
*ret
=
248 (struct alpha_elf_link_hash_entry
*) entry
;
250 /* Allocate the structure if it has not already been allocated by a
252 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
253 ret
= ((struct alpha_elf_link_hash_entry
*)
254 bfd_hash_allocate (table
,
255 sizeof (struct alpha_elf_link_hash_entry
)));
256 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
257 return (struct bfd_hash_entry
*) ret
;
259 /* Call the allocation method of the superclass. */
260 ret
= ((struct alpha_elf_link_hash_entry
*)
261 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
263 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
265 /* Set local fields. */
266 memset (&ret
->esym
, 0, sizeof (EXTR
));
267 /* We use -2 as a marker to indicate that the information has
268 not been set. -1 means there is no associated ifd. */
271 ret
->got_entries
= NULL
;
272 ret
->reloc_entries
= NULL
;
275 return (struct bfd_hash_entry
*) ret
;
278 /* Create a Alpha ELF linker hash table. */
280 static struct bfd_link_hash_table
*
281 elf64_alpha_bfd_link_hash_table_create (bfd
*abfd
)
283 struct alpha_elf_link_hash_table
*ret
;
284 size_t amt
= sizeof (struct alpha_elf_link_hash_table
);
286 ret
= (struct alpha_elf_link_hash_table
*) bfd_zmalloc (amt
);
287 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
290 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
291 elf64_alpha_link_hash_newfunc
,
292 sizeof (struct alpha_elf_link_hash_entry
),
299 return &ret
->root
.root
;
302 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
303 routine in order to handle the ECOFF debugging information. */
305 struct alpha_elf_find_line
307 struct ecoff_debug_info d
;
308 struct ecoff_find_line i
;
311 /* We have some private fields hanging off of the elf_tdata structure. */
313 struct alpha_elf_obj_tdata
315 struct elf_obj_tdata root
;
317 /* For every input file, these are the got entries for that object's
319 struct alpha_elf_got_entry
** local_got_entries
;
321 /* For every input file, this is the object that owns the got that
322 this input file uses. */
325 /* For every got, this is a linked list through the objects using this got */
326 bfd
*in_got_link_next
;
328 /* For every got, this is a link to the next got subsegment. */
331 /* For every got, this is the section. */
334 /* For every got, this is it's total number of words. */
337 /* For every got, this is the sum of the number of words required
338 to hold all of the member object's local got. */
341 /* Used by elf64_alpha_find_nearest_line entry point. */
342 struct alpha_elf_find_line
*find_line_info
;
346 #define alpha_elf_tdata(abfd) \
347 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
349 #define is_alpha_elf(bfd) \
350 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
351 && elf_tdata (bfd) != NULL \
352 && elf_object_id (bfd) == ALPHA_ELF_DATA)
355 elf64_alpha_mkobject (bfd
*abfd
)
357 return bfd_elf_allocate_object (abfd
, sizeof (struct alpha_elf_obj_tdata
),
362 elf64_alpha_object_p (bfd
*abfd
)
364 /* Set the right machine number for an Alpha ELF file. */
365 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
368 /* A relocation function which doesn't do anything. */
370 static bfd_reloc_status_type
371 elf64_alpha_reloc_nil (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc
,
372 asymbol
*sym ATTRIBUTE_UNUSED
,
373 void * data ATTRIBUTE_UNUSED
, asection
*sec
,
374 bfd
*output_bfd
, char **error_message ATTRIBUTE_UNUSED
)
377 reloc
->address
+= sec
->output_offset
;
381 /* A relocation function used for an unsupported reloc. */
383 static bfd_reloc_status_type
384 elf64_alpha_reloc_bad (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc
,
385 asymbol
*sym ATTRIBUTE_UNUSED
,
386 void * data ATTRIBUTE_UNUSED
, asection
*sec
,
387 bfd
*output_bfd
, char **error_message ATTRIBUTE_UNUSED
)
390 reloc
->address
+= sec
->output_offset
;
391 return bfd_reloc_notsupported
;
394 /* Do the work of the GPDISP relocation. */
396 static bfd_reloc_status_type
397 elf64_alpha_do_reloc_gpdisp (bfd
*abfd
, bfd_vma gpdisp
, bfd_byte
*p_ldah
,
400 bfd_reloc_status_type ret
= bfd_reloc_ok
;
402 unsigned long i_ldah
, i_lda
;
404 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
405 i_lda
= bfd_get_32 (abfd
, p_lda
);
407 /* Complain if the instructions are not correct. */
408 if (((i_ldah
>> 26) & 0x3f) != 0x09
409 || ((i_lda
>> 26) & 0x3f) != 0x08)
410 ret
= bfd_reloc_dangerous
;
412 /* Extract the user-supplied offset, mirroring the sign extensions
413 that the instructions perform. */
414 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
415 addend
= (addend
^ 0x80008000) - 0x80008000;
419 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
420 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
421 ret
= bfd_reloc_overflow
;
423 /* compensate for the sign extension again. */
424 i_ldah
= ((i_ldah
& 0xffff0000)
425 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
426 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
428 bfd_put_32 (abfd
, (bfd_vma
) i_ldah
, p_ldah
);
429 bfd_put_32 (abfd
, (bfd_vma
) i_lda
, p_lda
);
434 /* The special function for the GPDISP reloc. */
436 static bfd_reloc_status_type
437 elf64_alpha_reloc_gpdisp (bfd
*abfd
, arelent
*reloc_entry
,
438 asymbol
*sym ATTRIBUTE_UNUSED
, void * data
,
439 asection
*input_section
, bfd
*output_bfd
,
442 bfd_reloc_status_type ret
;
443 bfd_vma gp
, relocation
;
444 bfd_vma high_address
;
445 bfd_byte
*p_ldah
, *p_lda
;
447 /* Don't do anything if we're not doing a final link. */
450 reloc_entry
->address
+= input_section
->output_offset
;
454 high_address
= bfd_get_section_limit (abfd
, input_section
);
455 if (reloc_entry
->address
> high_address
456 || reloc_entry
->address
+ reloc_entry
->addend
> high_address
)
457 return bfd_reloc_outofrange
;
459 /* The gp used in the portion of the output object to which this
460 input object belongs is cached on the input bfd. */
461 gp
= _bfd_get_gp_value (abfd
);
463 relocation
= (input_section
->output_section
->vma
464 + input_section
->output_offset
465 + reloc_entry
->address
);
467 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
468 p_lda
= p_ldah
+ reloc_entry
->addend
;
470 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
472 /* Complain if the instructions are not correct. */
473 if (ret
== bfd_reloc_dangerous
)
474 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
479 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
480 from smaller values. Start with zero, widen, *then* decrement. */
481 #define MINUS_ONE (((bfd_vma)0) - 1)
484 #define SKIP_HOWTO(N) \
485 HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
487 static reloc_howto_type elf64_alpha_howto_table
[] =
489 HOWTO (R_ALPHA_NONE
, /* type */
491 3, /* size (0 = byte, 1 = short, 2 = long) */
493 true, /* pc_relative */
495 complain_overflow_dont
, /* complain_on_overflow */
496 elf64_alpha_reloc_nil
, /* special_function */
498 false, /* partial_inplace */
501 true), /* pcrel_offset */
503 /* A 32 bit reference to a symbol. */
504 HOWTO (R_ALPHA_REFLONG
, /* type */
506 2, /* size (0 = byte, 1 = short, 2 = long) */
508 false, /* pc_relative */
510 complain_overflow_bitfield
, /* complain_on_overflow */
511 bfd_elf_generic_reloc
, /* special_function */
512 "REFLONG", /* name */
513 false, /* partial_inplace */
514 0xffffffff, /* src_mask */
515 0xffffffff, /* dst_mask */
516 false), /* pcrel_offset */
518 /* A 64 bit reference to a symbol. */
519 HOWTO (R_ALPHA_REFQUAD
, /* type */
521 4, /* size (0 = byte, 1 = short, 2 = long) */
523 false, /* pc_relative */
525 complain_overflow_bitfield
, /* complain_on_overflow */
526 bfd_elf_generic_reloc
, /* special_function */
527 "REFQUAD", /* name */
528 false, /* partial_inplace */
529 MINUS_ONE
, /* src_mask */
530 MINUS_ONE
, /* dst_mask */
531 false), /* pcrel_offset */
533 /* A 32 bit GP relative offset. This is just like REFLONG except
534 that when the value is used the value of the gp register will be
536 HOWTO (R_ALPHA_GPREL32
, /* type */
538 2, /* size (0 = byte, 1 = short, 2 = long) */
540 false, /* pc_relative */
542 complain_overflow_bitfield
, /* complain_on_overflow */
543 bfd_elf_generic_reloc
, /* special_function */
544 "GPREL32", /* name */
545 false, /* partial_inplace */
546 0xffffffff, /* src_mask */
547 0xffffffff, /* dst_mask */
548 false), /* pcrel_offset */
550 /* Used for an instruction that refers to memory off the GP register. */
551 HOWTO (R_ALPHA_LITERAL
, /* type */
553 1, /* size (0 = byte, 1 = short, 2 = long) */
555 false, /* pc_relative */
557 complain_overflow_signed
, /* complain_on_overflow */
558 bfd_elf_generic_reloc
, /* special_function */
559 "ELF_LITERAL", /* name */
560 false, /* partial_inplace */
561 0xffff, /* src_mask */
562 0xffff, /* dst_mask */
563 false), /* pcrel_offset */
565 /* This reloc only appears immediately following an ELF_LITERAL reloc.
566 It identifies a use of the literal. The symbol index is special:
567 1 means the literal address is in the base register of a memory
568 format instruction; 2 means the literal address is in the byte
569 offset register of a byte-manipulation instruction; 3 means the
570 literal address is in the target register of a jsr instruction.
571 This does not actually do any relocation. */
572 HOWTO (R_ALPHA_LITUSE
, /* type */
574 1, /* size (0 = byte, 1 = short, 2 = long) */
576 false, /* pc_relative */
578 complain_overflow_dont
, /* complain_on_overflow */
579 elf64_alpha_reloc_nil
, /* special_function */
581 false, /* partial_inplace */
584 false), /* pcrel_offset */
586 /* Load the gp register. This is always used for a ldah instruction
587 which loads the upper 16 bits of the gp register. The symbol
588 index of the GPDISP instruction is an offset in bytes to the lda
589 instruction that loads the lower 16 bits. The value to use for
590 the relocation is the difference between the GP value and the
591 current location; the load will always be done against a register
592 holding the current address.
594 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
595 any offset is present in the instructions, it is an offset from
596 the register to the ldah instruction. This lets us avoid any
597 stupid hackery like inventing a gp value to do partial relocation
598 against. Also unlike ECOFF, we do the whole relocation off of
599 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
600 space consuming bit, that, since all the information was present
601 in the GPDISP_HI16 reloc. */
602 HOWTO (R_ALPHA_GPDISP
, /* type */
604 2, /* size (0 = byte, 1 = short, 2 = long) */
606 false, /* pc_relative */
608 complain_overflow_dont
, /* complain_on_overflow */
609 elf64_alpha_reloc_gpdisp
, /* special_function */
611 false, /* partial_inplace */
612 0xffff, /* src_mask */
613 0xffff, /* dst_mask */
614 true), /* pcrel_offset */
616 /* A 21 bit branch. */
617 HOWTO (R_ALPHA_BRADDR
, /* type */
619 2, /* size (0 = byte, 1 = short, 2 = long) */
621 true, /* pc_relative */
623 complain_overflow_signed
, /* complain_on_overflow */
624 bfd_elf_generic_reloc
, /* special_function */
626 false, /* partial_inplace */
627 0x1fffff, /* src_mask */
628 0x1fffff, /* dst_mask */
629 true), /* pcrel_offset */
631 /* A hint for a jump to a register. */
632 HOWTO (R_ALPHA_HINT
, /* type */
634 1, /* size (0 = byte, 1 = short, 2 = long) */
636 true, /* pc_relative */
638 complain_overflow_dont
, /* complain_on_overflow */
639 bfd_elf_generic_reloc
, /* special_function */
641 false, /* partial_inplace */
642 0x3fff, /* src_mask */
643 0x3fff, /* dst_mask */
644 true), /* pcrel_offset */
646 /* 16 bit PC relative offset. */
647 HOWTO (R_ALPHA_SREL16
, /* type */
649 1, /* size (0 = byte, 1 = short, 2 = long) */
651 true, /* pc_relative */
653 complain_overflow_signed
, /* complain_on_overflow */
654 bfd_elf_generic_reloc
, /* special_function */
656 false, /* partial_inplace */
657 0xffff, /* src_mask */
658 0xffff, /* dst_mask */
659 true), /* pcrel_offset */
661 /* 32 bit PC relative offset. */
662 HOWTO (R_ALPHA_SREL32
, /* type */
664 2, /* size (0 = byte, 1 = short, 2 = long) */
666 true, /* pc_relative */
668 complain_overflow_signed
, /* complain_on_overflow */
669 bfd_elf_generic_reloc
, /* special_function */
671 false, /* partial_inplace */
672 0xffffffff, /* src_mask */
673 0xffffffff, /* dst_mask */
674 true), /* pcrel_offset */
676 /* A 64 bit PC relative offset. */
677 HOWTO (R_ALPHA_SREL64
, /* type */
679 4, /* size (0 = byte, 1 = short, 2 = long) */
681 true, /* pc_relative */
683 complain_overflow_signed
, /* complain_on_overflow */
684 bfd_elf_generic_reloc
, /* special_function */
686 false, /* partial_inplace */
687 MINUS_ONE
, /* src_mask */
688 MINUS_ONE
, /* dst_mask */
689 true), /* pcrel_offset */
691 /* Skip 12 - 16; deprecated ECOFF relocs. */
698 /* The high 16 bits of the displacement from GP to the target. */
699 HOWTO (R_ALPHA_GPRELHIGH
,
701 1, /* size (0 = byte, 1 = short, 2 = long) */
703 false, /* pc_relative */
705 complain_overflow_signed
, /* complain_on_overflow */
706 bfd_elf_generic_reloc
, /* special_function */
707 "GPRELHIGH", /* name */
708 false, /* partial_inplace */
709 0xffff, /* src_mask */
710 0xffff, /* dst_mask */
711 false), /* pcrel_offset */
713 /* The low 16 bits of the displacement from GP to the target. */
714 HOWTO (R_ALPHA_GPRELLOW
,
716 1, /* size (0 = byte, 1 = short, 2 = long) */
718 false, /* pc_relative */
720 complain_overflow_dont
, /* complain_on_overflow */
721 bfd_elf_generic_reloc
, /* special_function */
722 "GPRELLOW", /* name */
723 false, /* partial_inplace */
724 0xffff, /* src_mask */
725 0xffff, /* dst_mask */
726 false), /* pcrel_offset */
728 /* A 16-bit displacement from the GP to the target. */
729 HOWTO (R_ALPHA_GPREL16
,
731 1, /* size (0 = byte, 1 = short, 2 = long) */
733 false, /* pc_relative */
735 complain_overflow_signed
, /* complain_on_overflow */
736 bfd_elf_generic_reloc
, /* special_function */
737 "GPREL16", /* name */
738 false, /* partial_inplace */
739 0xffff, /* src_mask */
740 0xffff, /* dst_mask */
741 false), /* pcrel_offset */
743 /* Skip 20 - 23; deprecated ECOFF relocs. */
749 /* Misc ELF relocations. */
751 /* A dynamic relocation to copy the target into our .dynbss section. */
752 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
753 is present because every other ELF has one, but should not be used
754 because .dynbss is an ugly thing. */
761 complain_overflow_dont
,
762 bfd_elf_generic_reloc
,
769 /* A dynamic relocation for a .got entry. */
770 HOWTO (R_ALPHA_GLOB_DAT
,
776 complain_overflow_dont
,
777 bfd_elf_generic_reloc
,
784 /* A dynamic relocation for a .plt entry. */
785 HOWTO (R_ALPHA_JMP_SLOT
,
791 complain_overflow_dont
,
792 bfd_elf_generic_reloc
,
799 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
800 HOWTO (R_ALPHA_RELATIVE
,
806 complain_overflow_dont
,
807 bfd_elf_generic_reloc
,
814 /* A 21 bit branch that adjusts for gp loads. */
815 HOWTO (R_ALPHA_BRSGP
, /* type */
817 2, /* size (0 = byte, 1 = short, 2 = long) */
819 true, /* pc_relative */
821 complain_overflow_signed
, /* complain_on_overflow */
822 bfd_elf_generic_reloc
, /* special_function */
824 false, /* partial_inplace */
825 0x1fffff, /* src_mask */
826 0x1fffff, /* dst_mask */
827 true), /* pcrel_offset */
829 /* Creates a tls_index for the symbol in the got. */
830 HOWTO (R_ALPHA_TLSGD
, /* type */
832 1, /* size (0 = byte, 1 = short, 2 = long) */
834 false, /* pc_relative */
836 complain_overflow_signed
, /* complain_on_overflow */
837 bfd_elf_generic_reloc
, /* special_function */
839 false, /* partial_inplace */
840 0xffff, /* src_mask */
841 0xffff, /* dst_mask */
842 false), /* pcrel_offset */
844 /* Creates a tls_index for the (current) module in the got. */
845 HOWTO (R_ALPHA_TLSLDM
, /* type */
847 1, /* size (0 = byte, 1 = short, 2 = long) */
849 false, /* pc_relative */
851 complain_overflow_signed
, /* complain_on_overflow */
852 bfd_elf_generic_reloc
, /* special_function */
854 false, /* partial_inplace */
855 0xffff, /* src_mask */
856 0xffff, /* dst_mask */
857 false), /* pcrel_offset */
859 /* A dynamic relocation for a DTP module entry. */
860 HOWTO (R_ALPHA_DTPMOD64
, /* type */
862 4, /* size (0 = byte, 1 = short, 2 = long) */
864 false, /* pc_relative */
866 complain_overflow_bitfield
, /* complain_on_overflow */
867 bfd_elf_generic_reloc
, /* special_function */
868 "DTPMOD64", /* name */
869 false, /* partial_inplace */
870 MINUS_ONE
, /* src_mask */
871 MINUS_ONE
, /* dst_mask */
872 false), /* pcrel_offset */
874 /* Creates a 64-bit offset in the got for the displacement
875 from DTP to the target. */
876 HOWTO (R_ALPHA_GOTDTPREL
, /* type */
878 1, /* size (0 = byte, 1 = short, 2 = long) */
880 false, /* pc_relative */
882 complain_overflow_signed
, /* complain_on_overflow */
883 bfd_elf_generic_reloc
, /* special_function */
884 "GOTDTPREL", /* name */
885 false, /* partial_inplace */
886 0xffff, /* src_mask */
887 0xffff, /* dst_mask */
888 false), /* pcrel_offset */
890 /* A dynamic relocation for a displacement from DTP to the target. */
891 HOWTO (R_ALPHA_DTPREL64
, /* type */
893 4, /* size (0 = byte, 1 = short, 2 = long) */
895 false, /* pc_relative */
897 complain_overflow_bitfield
, /* complain_on_overflow */
898 bfd_elf_generic_reloc
, /* special_function */
899 "DTPREL64", /* name */
900 false, /* partial_inplace */
901 MINUS_ONE
, /* src_mask */
902 MINUS_ONE
, /* dst_mask */
903 false), /* pcrel_offset */
905 /* The high 16 bits of the displacement from DTP to the target. */
906 HOWTO (R_ALPHA_DTPRELHI
, /* type */
908 1, /* size (0 = byte, 1 = short, 2 = long) */
910 false, /* pc_relative */
912 complain_overflow_signed
, /* complain_on_overflow */
913 bfd_elf_generic_reloc
, /* special_function */
914 "DTPRELHI", /* name */
915 false, /* partial_inplace */
916 0xffff, /* src_mask */
917 0xffff, /* dst_mask */
918 false), /* pcrel_offset */
920 /* The low 16 bits of the displacement from DTP to the target. */
921 HOWTO (R_ALPHA_DTPRELLO
, /* type */
923 1, /* size (0 = byte, 1 = short, 2 = long) */
925 false, /* pc_relative */
927 complain_overflow_dont
, /* complain_on_overflow */
928 bfd_elf_generic_reloc
, /* special_function */
929 "DTPRELLO", /* name */
930 false, /* partial_inplace */
931 0xffff, /* src_mask */
932 0xffff, /* dst_mask */
933 false), /* pcrel_offset */
935 /* A 16-bit displacement from DTP to the target. */
936 HOWTO (R_ALPHA_DTPREL16
, /* type */
938 1, /* size (0 = byte, 1 = short, 2 = long) */
940 false, /* pc_relative */
942 complain_overflow_signed
, /* complain_on_overflow */
943 bfd_elf_generic_reloc
, /* special_function */
944 "DTPREL16", /* name */
945 false, /* partial_inplace */
946 0xffff, /* src_mask */
947 0xffff, /* dst_mask */
948 false), /* pcrel_offset */
950 /* Creates a 64-bit offset in the got for the displacement
951 from TP to the target. */
952 HOWTO (R_ALPHA_GOTTPREL
, /* type */
954 1, /* size (0 = byte, 1 = short, 2 = long) */
956 false, /* pc_relative */
958 complain_overflow_signed
, /* complain_on_overflow */
959 bfd_elf_generic_reloc
, /* special_function */
960 "GOTTPREL", /* name */
961 false, /* partial_inplace */
962 0xffff, /* src_mask */
963 0xffff, /* dst_mask */
964 false), /* pcrel_offset */
966 /* A dynamic relocation for a displacement from TP to the target. */
967 HOWTO (R_ALPHA_TPREL64
, /* type */
969 4, /* size (0 = byte, 1 = short, 2 = long) */
971 false, /* pc_relative */
973 complain_overflow_bitfield
, /* complain_on_overflow */
974 bfd_elf_generic_reloc
, /* special_function */
975 "TPREL64", /* name */
976 false, /* partial_inplace */
977 MINUS_ONE
, /* src_mask */
978 MINUS_ONE
, /* dst_mask */
979 false), /* pcrel_offset */
981 /* The high 16 bits of the displacement from TP to the target. */
982 HOWTO (R_ALPHA_TPRELHI
, /* type */
984 1, /* size (0 = byte, 1 = short, 2 = long) */
986 false, /* pc_relative */
988 complain_overflow_signed
, /* complain_on_overflow */
989 bfd_elf_generic_reloc
, /* special_function */
990 "TPRELHI", /* name */
991 false, /* partial_inplace */
992 0xffff, /* src_mask */
993 0xffff, /* dst_mask */
994 false), /* pcrel_offset */
996 /* The low 16 bits of the displacement from TP to the target. */
997 HOWTO (R_ALPHA_TPRELLO
, /* type */
999 1, /* size (0 = byte, 1 = short, 2 = long) */
1001 false, /* pc_relative */
1003 complain_overflow_dont
, /* complain_on_overflow */
1004 bfd_elf_generic_reloc
, /* special_function */
1005 "TPRELLO", /* name */
1006 false, /* partial_inplace */
1007 0xffff, /* src_mask */
1008 0xffff, /* dst_mask */
1009 false), /* pcrel_offset */
1011 /* A 16-bit displacement from TP to the target. */
1012 HOWTO (R_ALPHA_TPREL16
, /* type */
1014 1, /* size (0 = byte, 1 = short, 2 = long) */
1016 false, /* pc_relative */
1018 complain_overflow_signed
, /* complain_on_overflow */
1019 bfd_elf_generic_reloc
, /* special_function */
1020 "TPREL16", /* name */
1021 false, /* partial_inplace */
1022 0xffff, /* src_mask */
1023 0xffff, /* dst_mask */
1024 false), /* pcrel_offset */
1027 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1029 struct elf_reloc_map
1031 bfd_reloc_code_real_type bfd_reloc_val
;
1035 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
1037 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
1038 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
1039 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
1040 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
1041 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
1042 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
1043 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
1044 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
1045 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
1046 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
1047 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
1048 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
1049 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
1050 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
1051 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
1052 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
1053 {BFD_RELOC_ALPHA_BRSGP
, R_ALPHA_BRSGP
},
1054 {BFD_RELOC_ALPHA_TLSGD
, R_ALPHA_TLSGD
},
1055 {BFD_RELOC_ALPHA_TLSLDM
, R_ALPHA_TLSLDM
},
1056 {BFD_RELOC_ALPHA_DTPMOD64
, R_ALPHA_DTPMOD64
},
1057 {BFD_RELOC_ALPHA_GOTDTPREL16
, R_ALPHA_GOTDTPREL
},
1058 {BFD_RELOC_ALPHA_DTPREL64
, R_ALPHA_DTPREL64
},
1059 {BFD_RELOC_ALPHA_DTPREL_HI16
, R_ALPHA_DTPRELHI
},
1060 {BFD_RELOC_ALPHA_DTPREL_LO16
, R_ALPHA_DTPRELLO
},
1061 {BFD_RELOC_ALPHA_DTPREL16
, R_ALPHA_DTPREL16
},
1062 {BFD_RELOC_ALPHA_GOTTPREL16
, R_ALPHA_GOTTPREL
},
1063 {BFD_RELOC_ALPHA_TPREL64
, R_ALPHA_TPREL64
},
1064 {BFD_RELOC_ALPHA_TPREL_HI16
, R_ALPHA_TPRELHI
},
1065 {BFD_RELOC_ALPHA_TPREL_LO16
, R_ALPHA_TPRELLO
},
1066 {BFD_RELOC_ALPHA_TPREL16
, R_ALPHA_TPREL16
},
1069 /* Given a BFD reloc type, return a HOWTO structure. */
1071 static reloc_howto_type
*
1072 elf64_alpha_bfd_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1073 bfd_reloc_code_real_type code
)
1075 const struct elf_reloc_map
*i
, *e
;
1076 i
= e
= elf64_alpha_reloc_map
;
1077 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1080 if (i
->bfd_reloc_val
== code
)
1081 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1086 static reloc_howto_type
*
1087 elf64_alpha_bfd_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1093 i
< (sizeof (elf64_alpha_howto_table
)
1094 / sizeof (elf64_alpha_howto_table
[0]));
1096 if (elf64_alpha_howto_table
[i
].name
!= NULL
1097 && strcasecmp (elf64_alpha_howto_table
[i
].name
, r_name
) == 0)
1098 return &elf64_alpha_howto_table
[i
];
1103 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1106 elf64_alpha_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1107 Elf_Internal_Rela
*dst
)
1109 unsigned r_type
= ELF64_R_TYPE(dst
->r_info
);
1111 if (r_type
>= R_ALPHA_max
)
1113 /* xgettext:c-format */
1114 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1116 bfd_set_error (bfd_error_bad_value
);
1119 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1123 /* These two relocations create a two-word entry in the got. */
1124 #define alpha_got_entry_size(r_type) \
1125 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1127 /* This is PT_TLS segment p_vaddr. */
1128 #define alpha_get_dtprel_base(info) \
1129 (elf_hash_table (info)->tls_sec->vma)
1131 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1132 is assigned offset round(16, PT_TLS p_align). */
1133 #define alpha_get_tprel_base(info) \
1134 (elf_hash_table (info)->tls_sec->vma \
1135 - align_power ((bfd_vma) 16, \
1136 elf_hash_table (info)->tls_sec->alignment_power))
1138 /* Handle an Alpha specific section when reading an object file. This
1139 is called when bfd_section_from_shdr finds a section with an unknown
1143 elf64_alpha_section_from_shdr (bfd
*abfd
,
1144 Elf_Internal_Shdr
*hdr
,
1150 /* There ought to be a place to keep ELF backend specific flags, but
1151 at the moment there isn't one. We just keep track of the
1152 sections by their name, instead. Fortunately, the ABI gives
1153 suggested names for all the MIPS specific sections, so we will
1154 probably get away with this. */
1155 switch (hdr
->sh_type
)
1157 case SHT_ALPHA_DEBUG
:
1158 if (strcmp (name
, ".mdebug") != 0)
1165 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1167 newsect
= hdr
->bfd_section
;
1169 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
1171 if (!bfd_set_section_flags (newsect
,
1172 bfd_section_flags (newsect
) | SEC_DEBUGGING
))
1179 /* Convert Alpha specific section flags to bfd internal section flags. */
1182 elf64_alpha_section_flags (const Elf_Internal_Shdr
*hdr
)
1184 if (hdr
->sh_flags
& SHF_ALPHA_GPREL
)
1185 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
1190 /* Set the correct type for an Alpha ELF section. We do this by the
1191 section name, which is a hack, but ought to work. */
1194 elf64_alpha_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
1196 register const char *name
;
1198 name
= bfd_section_name (sec
);
1200 if (strcmp (name
, ".mdebug") == 0)
1202 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
1203 /* In a shared object on Irix 5.3, the .mdebug section has an
1204 entsize of 0. FIXME: Does this matter? */
1205 if ((abfd
->flags
& DYNAMIC
) != 0 )
1206 hdr
->sh_entsize
= 0;
1208 hdr
->sh_entsize
= 1;
1210 else if ((sec
->flags
& SEC_SMALL_DATA
)
1211 || strcmp (name
, ".sdata") == 0
1212 || strcmp (name
, ".sbss") == 0
1213 || strcmp (name
, ".lit4") == 0
1214 || strcmp (name
, ".lit8") == 0)
1215 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
1220 /* Hook called by the linker routine which adds symbols from an object
1221 file. We use it to put .comm items in .sbss, and not .bss. */
1224 elf64_alpha_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1225 Elf_Internal_Sym
*sym
,
1226 const char **namep ATTRIBUTE_UNUSED
,
1227 flagword
*flagsp ATTRIBUTE_UNUSED
,
1228 asection
**secp
, bfd_vma
*valp
)
1230 if (sym
->st_shndx
== SHN_COMMON
1231 && !bfd_link_relocatable (info
)
1232 && sym
->st_size
<= elf_gp_size (abfd
))
1234 /* Common symbols less than or equal to -G nn bytes are
1235 automatically put into .sbss. */
1237 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1241 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1245 | SEC_LINKER_CREATED
));
1251 *valp
= sym
->st_size
;
1257 /* Create the .got section. */
1260 elf64_alpha_create_got_section (bfd
*abfd
,
1261 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1266 if (! is_alpha_elf (abfd
))
1269 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1270 | SEC_LINKER_CREATED
);
1271 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
1273 || !bfd_set_section_alignment (s
, 3))
1276 alpha_elf_tdata (abfd
)->got
= s
;
1278 /* Make sure the object's gotobj is set to itself so that we default
1279 to every object with its own .got. We'll merge .gots later once
1280 we've collected each object's info. */
1281 alpha_elf_tdata (abfd
)->gotobj
= abfd
;
1286 /* Create all the dynamic sections. */
1289 elf64_alpha_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
1293 struct elf_link_hash_entry
*h
;
1295 if (! is_alpha_elf (abfd
))
1298 /* We need to create .plt, .rela.plt, .got, and .rela.got sections. */
1300 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1301 | SEC_LINKER_CREATED
1302 | (elf64_alpha_use_secureplt
? SEC_READONLY
: 0));
1303 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", flags
);
1304 elf_hash_table (info
)->splt
= s
;
1305 if (s
== NULL
|| ! bfd_set_section_alignment (s
, 4))
1308 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1310 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
1311 "_PROCEDURE_LINKAGE_TABLE_");
1312 elf_hash_table (info
)->hplt
= h
;
1316 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1317 | SEC_LINKER_CREATED
| SEC_READONLY
);
1318 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.plt", flags
);
1319 elf_hash_table (info
)->srelplt
= s
;
1320 if (s
== NULL
|| ! bfd_set_section_alignment (s
, 3))
1323 if (elf64_alpha_use_secureplt
)
1325 flags
= SEC_ALLOC
| SEC_LINKER_CREATED
;
1326 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
1327 elf_hash_table (info
)->sgotplt
= s
;
1328 if (s
== NULL
|| ! bfd_set_section_alignment (s
, 3))
1332 /* We may or may not have created a .got section for this object, but
1333 we definitely havn't done the rest of the work. */
1335 if (alpha_elf_tdata(abfd
)->gotobj
== NULL
)
1337 if (!elf64_alpha_create_got_section (abfd
, info
))
1341 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
1342 | SEC_LINKER_CREATED
| SEC_READONLY
);
1343 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.got", flags
);
1344 elf_hash_table (info
)->srelgot
= s
;
1346 || !bfd_set_section_alignment (s
, 3))
1349 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1350 dynobj's .got section. We don't do this in the linker script
1351 because we don't want to define the symbol if we are not creating
1352 a global offset table. */
1353 h
= _bfd_elf_define_linkage_sym (abfd
, info
, alpha_elf_tdata(abfd
)->got
,
1354 "_GLOBAL_OFFSET_TABLE_");
1355 elf_hash_table (info
)->hgot
= h
;
1362 /* Read ECOFF debugging information from a .mdebug section into a
1363 ecoff_debug_info structure. */
1366 elf64_alpha_read_ecoff_info (bfd
*abfd
, asection
*section
,
1367 struct ecoff_debug_info
*debug
)
1370 const struct ecoff_debug_swap
*swap
;
1371 char *ext_hdr
= NULL
;
1373 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1374 memset (debug
, 0, sizeof (*debug
));
1376 ext_hdr
= (char *) bfd_malloc (swap
->external_hdr_size
);
1377 if (ext_hdr
== NULL
&& swap
->external_hdr_size
!= 0)
1380 if (! bfd_get_section_contents (abfd
, section
, ext_hdr
, (file_ptr
) 0,
1381 swap
->external_hdr_size
))
1384 symhdr
= &debug
->symbolic_header
;
1385 (*swap
->swap_hdr_in
) (abfd
, ext_hdr
, symhdr
);
1387 /* The symbolic header contains absolute file offsets and sizes to
1389 #define READ(ptr, offset, count, size, type) \
1393 debug->ptr = NULL; \
1394 if (symhdr->count == 0) \
1396 if (_bfd_mul_overflow (size, symhdr->count, &amt)) \
1398 bfd_set_error (bfd_error_file_too_big); \
1399 goto error_return; \
1401 if (bfd_seek (abfd, symhdr->offset, SEEK_SET) != 0) \
1402 goto error_return; \
1403 debug->ptr = (type) _bfd_malloc_and_read (abfd, amt, amt); \
1404 if (debug->ptr == NULL) \
1405 goto error_return; \
1408 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1409 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
1410 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
1411 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
1412 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
1413 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1415 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1416 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1417 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
1418 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
1419 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
1429 free (debug
->external_dnr
);
1430 free (debug
->external_pdr
);
1431 free (debug
->external_sym
);
1432 free (debug
->external_opt
);
1433 free (debug
->external_aux
);
1435 free (debug
->ssext
);
1436 free (debug
->external_fdr
);
1437 free (debug
->external_rfd
);
1438 free (debug
->external_ext
);
1442 /* Alpha ELF local labels start with '$'. */
1445 elf64_alpha_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
, const char *name
)
1447 return name
[0] == '$';
1451 elf64_alpha_find_nearest_line (bfd
*abfd
, asymbol
**symbols
,
1452 asection
*section
, bfd_vma offset
,
1453 const char **filename_ptr
,
1454 const char **functionname_ptr
,
1455 unsigned int *line_ptr
,
1456 unsigned int *discriminator_ptr
)
1460 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
1461 filename_ptr
, functionname_ptr
,
1462 line_ptr
, discriminator_ptr
,
1463 dwarf_debug_sections
,
1464 &elf_tdata (abfd
)->dwarf2_find_line_info
)
1468 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
1472 struct alpha_elf_find_line
*fi
;
1473 const struct ecoff_debug_swap
* const swap
=
1474 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1476 /* If we are called during a link, alpha_elf_final_link may have
1477 cleared the SEC_HAS_CONTENTS field. We force it back on here
1478 if appropriate (which it normally will be). */
1479 origflags
= msec
->flags
;
1480 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
1481 msec
->flags
|= SEC_HAS_CONTENTS
;
1483 fi
= alpha_elf_tdata (abfd
)->find_line_info
;
1486 bfd_size_type external_fdr_size
;
1489 struct fdr
*fdr_ptr
;
1490 bfd_size_type amt
= sizeof (struct alpha_elf_find_line
);
1492 fi
= (struct alpha_elf_find_line
*) bfd_zalloc (abfd
, amt
);
1495 msec
->flags
= origflags
;
1499 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
1501 msec
->flags
= origflags
;
1505 /* Swap in the FDR information. */
1506 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
1507 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
1508 if (fi
->d
.fdr
== NULL
)
1510 msec
->flags
= origflags
;
1513 external_fdr_size
= swap
->external_fdr_size
;
1514 fdr_ptr
= fi
->d
.fdr
;
1515 fraw_src
= (char *) fi
->d
.external_fdr
;
1516 fraw_end
= (fraw_src
1517 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
1518 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
1519 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
1521 alpha_elf_tdata (abfd
)->find_line_info
= fi
;
1523 /* Note that we don't bother to ever free this information.
1524 find_nearest_line is either called all the time, as in
1525 objdump -l, so the information should be saved, or it is
1526 rarely called, as in ld error messages, so the memory
1527 wasted is unimportant. Still, it would probably be a
1528 good idea for free_cached_info to throw it away. */
1531 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
1532 &fi
->i
, filename_ptr
, functionname_ptr
,
1535 msec
->flags
= origflags
;
1539 msec
->flags
= origflags
;
1542 /* Fall back on the generic ELF find_nearest_line routine. */
1544 return _bfd_elf_find_nearest_line (abfd
, symbols
, section
, offset
,
1545 filename_ptr
, functionname_ptr
,
1546 line_ptr
, discriminator_ptr
);
1549 /* Structure used to pass information to alpha_elf_output_extsym. */
1554 struct bfd_link_info
*info
;
1555 struct ecoff_debug_info
*debug
;
1556 const struct ecoff_debug_swap
*swap
;
1561 elf64_alpha_output_extsym (struct elf_link_hash_entry
*x
, void * data
)
1563 struct alpha_elf_link_hash_entry
*h
= (struct alpha_elf_link_hash_entry
*) x
;
1564 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
1566 asection
*sec
, *output_section
;
1568 if (h
->root
.indx
== -2)
1570 else if ((h
->root
.def_dynamic
1571 || h
->root
.ref_dynamic
1572 || h
->root
.root
.type
== bfd_link_hash_new
)
1573 && !h
->root
.def_regular
1574 && !h
->root
.ref_regular
)
1576 else if (einfo
->info
->strip
== strip_all
1577 || (einfo
->info
->strip
== strip_some
1578 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1579 h
->root
.root
.root
.string
,
1580 false, false) == NULL
))
1588 if (h
->esym
.ifd
== -2)
1591 h
->esym
.cobol_main
= 0;
1592 h
->esym
.weakext
= 0;
1593 h
->esym
.reserved
= 0;
1594 h
->esym
.ifd
= ifdNil
;
1595 h
->esym
.asym
.value
= 0;
1596 h
->esym
.asym
.st
= stGlobal
;
1598 if (h
->root
.root
.type
!= bfd_link_hash_defined
1599 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1600 h
->esym
.asym
.sc
= scAbs
;
1605 sec
= h
->root
.root
.u
.def
.section
;
1606 output_section
= sec
->output_section
;
1608 /* When making a shared library and symbol h is the one from
1609 the another shared library, OUTPUT_SECTION may be null. */
1610 if (output_section
== NULL
)
1611 h
->esym
.asym
.sc
= scUndefined
;
1614 name
= bfd_section_name (output_section
);
1616 if (strcmp (name
, ".text") == 0)
1617 h
->esym
.asym
.sc
= scText
;
1618 else if (strcmp (name
, ".data") == 0)
1619 h
->esym
.asym
.sc
= scData
;
1620 else if (strcmp (name
, ".sdata") == 0)
1621 h
->esym
.asym
.sc
= scSData
;
1622 else if (strcmp (name
, ".rodata") == 0
1623 || strcmp (name
, ".rdata") == 0)
1624 h
->esym
.asym
.sc
= scRData
;
1625 else if (strcmp (name
, ".bss") == 0)
1626 h
->esym
.asym
.sc
= scBss
;
1627 else if (strcmp (name
, ".sbss") == 0)
1628 h
->esym
.asym
.sc
= scSBss
;
1629 else if (strcmp (name
, ".init") == 0)
1630 h
->esym
.asym
.sc
= scInit
;
1631 else if (strcmp (name
, ".fini") == 0)
1632 h
->esym
.asym
.sc
= scFini
;
1634 h
->esym
.asym
.sc
= scAbs
;
1638 h
->esym
.asym
.reserved
= 0;
1639 h
->esym
.asym
.index
= indexNil
;
1642 if (h
->root
.root
.type
== bfd_link_hash_common
)
1643 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1644 else if (h
->root
.root
.type
== bfd_link_hash_defined
1645 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1647 if (h
->esym
.asym
.sc
== scCommon
)
1648 h
->esym
.asym
.sc
= scBss
;
1649 else if (h
->esym
.asym
.sc
== scSCommon
)
1650 h
->esym
.asym
.sc
= scSBss
;
1652 sec
= h
->root
.root
.u
.def
.section
;
1653 output_section
= sec
->output_section
;
1654 if (output_section
!= NULL
)
1655 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1656 + sec
->output_offset
1657 + output_section
->vma
);
1659 h
->esym
.asym
.value
= 0;
1662 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1663 h
->root
.root
.root
.string
,
1666 einfo
->failed
= true;
1673 /* Search for and possibly create a got entry. */
1675 static struct alpha_elf_got_entry
*
1676 get_got_entry (bfd
*abfd
, struct alpha_elf_link_hash_entry
*h
,
1677 unsigned long r_type
, unsigned long r_symndx
,
1680 struct alpha_elf_got_entry
*gotent
;
1681 struct alpha_elf_got_entry
**slot
;
1684 slot
= &h
->got_entries
;
1687 /* This is a local .got entry -- record for merge. */
1689 struct alpha_elf_got_entry
**local_got_entries
;
1691 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1692 if (!local_got_entries
)
1695 Elf_Internal_Shdr
*symtab_hdr
;
1697 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
1698 size
= symtab_hdr
->sh_info
;
1699 size
*= sizeof (struct alpha_elf_got_entry
*);
1702 = (struct alpha_elf_got_entry
**) bfd_zalloc (abfd
, size
);
1703 if (!local_got_entries
)
1706 alpha_elf_tdata (abfd
)->local_got_entries
= local_got_entries
;
1709 slot
= &local_got_entries
[r_symndx
];
1712 for (gotent
= *slot
; gotent
; gotent
= gotent
->next
)
1713 if (gotent
->gotobj
== abfd
1714 && gotent
->reloc_type
== r_type
1715 && gotent
->addend
== r_addend
)
1723 amt
= sizeof (struct alpha_elf_got_entry
);
1724 gotent
= (struct alpha_elf_got_entry
*) bfd_alloc (abfd
, amt
);
1728 gotent
->gotobj
= abfd
;
1729 gotent
->addend
= r_addend
;
1730 gotent
->got_offset
= -1;
1731 gotent
->plt_offset
= -1;
1732 gotent
->use_count
= 1;
1733 gotent
->reloc_type
= r_type
;
1734 gotent
->reloc_done
= 0;
1735 gotent
->reloc_xlated
= 0;
1737 gotent
->next
= *slot
;
1740 entry_size
= alpha_got_entry_size (r_type
);
1741 alpha_elf_tdata (abfd
)->total_got_size
+= entry_size
;
1743 alpha_elf_tdata(abfd
)->local_got_size
+= entry_size
;
1746 gotent
->use_count
+= 1;
1752 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry
*ah
)
1754 return ((ah
->root
.type
== STT_FUNC
1755 || ah
->root
.root
.type
== bfd_link_hash_undefweak
1756 || ah
->root
.root
.type
== bfd_link_hash_undefined
)
1757 && (ah
->flags
& ALPHA_ELF_LINK_HASH_LU_PLT
) != 0
1758 && (ah
->flags
& ~ALPHA_ELF_LINK_HASH_LU_PLT
) == 0);
1761 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
1762 Don't do so for code sections. We want to keep ordering of LITERAL/LITUSE
1763 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
1764 relocs to be sorted. */
1767 elf64_alpha_sort_relocs_p (asection
*sec
)
1769 return (sec
->flags
& SEC_CODE
) == 0;
1773 /* Handle dynamic relocations when doing an Alpha ELF link. */
1776 elf64_alpha_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1777 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1781 Elf_Internal_Shdr
*symtab_hdr
;
1782 struct alpha_elf_link_hash_entry
**sym_hashes
;
1783 const Elf_Internal_Rela
*rel
, *relend
;
1785 if (bfd_link_relocatable (info
))
1788 BFD_ASSERT (is_alpha_elf (abfd
));
1790 dynobj
= elf_hash_table (info
)->dynobj
;
1792 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1795 symtab_hdr
= &elf_symtab_hdr (abfd
);
1796 sym_hashes
= alpha_elf_sym_hashes (abfd
);
1798 relend
= relocs
+ sec
->reloc_count
;
1799 for (rel
= relocs
; rel
< relend
; ++rel
)
1807 unsigned long r_symndx
, r_type
;
1808 struct alpha_elf_link_hash_entry
*h
;
1809 unsigned int gotent_flags
;
1814 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1815 if (r_symndx
< symtab_hdr
->sh_info
)
1819 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1821 while (h
->root
.root
.type
== bfd_link_hash_indirect
1822 || h
->root
.root
.type
== bfd_link_hash_warning
)
1823 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1825 /* PR15323, ref flags aren't set for references in the same
1827 h
->root
.ref_regular
= 1;
1830 /* We can only get preliminary data on whether a symbol is
1831 locally or externally defined, as not all of the input files
1832 have yet been processed. Do something with what we know, as
1833 this may help reduce memory usage and processing time later. */
1834 maybe_dynamic
= false;
1835 if (h
&& ((bfd_link_pic (info
)
1837 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
1838 || !h
->root
.def_regular
1839 || h
->root
.root
.type
== bfd_link_hash_defweak
))
1840 maybe_dynamic
= true;
1844 r_type
= ELF64_R_TYPE (rel
->r_info
);
1845 addend
= rel
->r_addend
;
1849 case R_ALPHA_LITERAL
:
1850 need
= NEED_GOT
| NEED_GOT_ENTRY
;
1852 /* Remember how this literal is used from its LITUSEs.
1853 This will be important when it comes to decide if we can
1854 create a .plt entry for a function symbol. */
1855 while (++rel
< relend
&& ELF64_R_TYPE (rel
->r_info
) == R_ALPHA_LITUSE
)
1856 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 6)
1857 gotent_flags
|= 1 << rel
->r_addend
;
1860 /* No LITUSEs -- presumably the address is used somehow. */
1861 if (gotent_flags
== 0)
1862 gotent_flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
1865 case R_ALPHA_GPDISP
:
1866 case R_ALPHA_GPREL16
:
1867 case R_ALPHA_GPREL32
:
1868 case R_ALPHA_GPRELHIGH
:
1869 case R_ALPHA_GPRELLOW
:
1874 case R_ALPHA_REFLONG
:
1875 case R_ALPHA_REFQUAD
:
1876 if (bfd_link_pic (info
) || maybe_dynamic
)
1880 case R_ALPHA_TLSLDM
:
1881 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1882 reloc to the STN_UNDEF (0) symbol so that they all match. */
1883 r_symndx
= STN_UNDEF
;
1885 maybe_dynamic
= false;
1889 case R_ALPHA_GOTDTPREL
:
1890 need
= NEED_GOT
| NEED_GOT_ENTRY
;
1893 case R_ALPHA_GOTTPREL
:
1894 need
= NEED_GOT
| NEED_GOT_ENTRY
;
1895 gotent_flags
= ALPHA_ELF_LINK_HASH_TLS_IE
;
1896 if (bfd_link_pic (info
))
1897 info
->flags
|= DF_STATIC_TLS
;
1900 case R_ALPHA_TPREL64
:
1901 if (bfd_link_dll (info
))
1903 info
->flags
|= DF_STATIC_TLS
;
1906 else if (maybe_dynamic
)
1911 if (need
& NEED_GOT
)
1913 if (alpha_elf_tdata(abfd
)->gotobj
== NULL
)
1915 if (!elf64_alpha_create_got_section (abfd
, info
))
1920 if (need
& NEED_GOT_ENTRY
)
1922 struct alpha_elf_got_entry
*gotent
;
1924 gotent
= get_got_entry (abfd
, h
, r_type
, r_symndx
, addend
);
1930 gotent
->flags
|= gotent_flags
;
1933 gotent_flags
|= h
->flags
;
1934 h
->flags
= gotent_flags
;
1936 /* Make a guess as to whether a .plt entry is needed. */
1937 /* ??? It appears that we won't make it into
1938 adjust_dynamic_symbol for symbols that remain
1939 totally undefined. Copying this check here means
1940 we can create a plt entry for them too. */
1942 = (maybe_dynamic
&& elf64_alpha_want_plt (h
));
1947 if (need
& NEED_DYNREL
)
1949 /* We need to create the section here now whether we eventually
1950 use it or not so that it gets mapped to an output section by
1951 the linker. If not used, we'll kill it in size_dynamic_sections. */
1954 sreloc
= _bfd_elf_make_dynamic_reloc_section
1955 (sec
, dynobj
, 3, abfd
, /*rela?*/ true);
1963 /* Since we havn't seen all of the input symbols yet, we
1964 don't know whether we'll actually need a dynamic relocation
1965 entry for this reloc. So make a record of it. Once we
1966 find out if this thing needs dynamic relocation we'll
1967 expand the relocation sections by the appropriate amount. */
1969 struct alpha_elf_reloc_entry
*rent
;
1971 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
1972 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
1977 size_t amt
= sizeof (struct alpha_elf_reloc_entry
);
1978 rent
= (struct alpha_elf_reloc_entry
*) bfd_alloc (abfd
, amt
);
1982 rent
->srel
= sreloc
;
1984 rent
->rtype
= r_type
;
1987 rent
->next
= h
->reloc_entries
;
1988 h
->reloc_entries
= rent
;
1993 else if (bfd_link_pic (info
))
1995 /* If this is a shared library, and the section is to be
1996 loaded into memory, we need a RELATIVE reloc. */
1997 sreloc
->size
+= sizeof (Elf64_External_Rela
);
1998 if (sec
->flags
& SEC_READONLY
)
2000 info
->flags
|= DF_TEXTREL
;
2001 info
->callbacks
->minfo
2002 (_("%pB: dynamic relocation against `%pT' in "
2003 "read-only section `%pA'\n"),
2004 sec
->owner
, h
->root
.root
.root
.string
, sec
);
2013 /* Return the section that should be marked against GC for a given
2017 elf64_alpha_gc_mark_hook (asection
*sec
, struct bfd_link_info
*info
,
2018 Elf_Internal_Rela
*rel
,
2019 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
)
2021 /* These relocations don't really reference a symbol. Instead we store
2022 extra data in their addend slot. Ignore the symbol. */
2023 switch (ELF64_R_TYPE (rel
->r_info
))
2025 case R_ALPHA_LITUSE
:
2026 case R_ALPHA_GPDISP
:
2031 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2034 /* Adjust a symbol defined by a dynamic object and referenced by a
2035 regular object. The current definition is in some section of the
2036 dynamic object, but we're not including those sections. We have to
2037 change the definition to something the rest of the link can
2041 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2042 struct elf_link_hash_entry
*h
)
2046 struct alpha_elf_link_hash_entry
*ah
;
2048 dynobj
= elf_hash_table(info
)->dynobj
;
2049 ah
= (struct alpha_elf_link_hash_entry
*)h
;
2051 /* Now that we've seen all of the input symbols, finalize our decision
2052 about whether this symbol should get a .plt entry. Irritatingly, it
2053 is common for folk to leave undefined symbols in shared libraries,
2054 and they still expect lazy binding; accept undefined symbols in lieu
2056 if (alpha_elf_dynamic_symbol_p (h
, info
) && elf64_alpha_want_plt (ah
))
2058 h
->needs_plt
= true;
2060 s
= elf_hash_table(info
)->splt
;
2061 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
2064 /* We need one plt entry per got subsection. Delay allocation of
2065 the actual plt entries until size_plt_section, called from
2066 size_dynamic_sections or during relaxation. */
2071 h
->needs_plt
= false;
2073 /* If this is a weak symbol, and there is a real definition, the
2074 processor independent code will have arranged for us to see the
2075 real definition first, and we can just use the same value. */
2076 if (h
->is_weakalias
)
2078 struct elf_link_hash_entry
*def
= weakdef (h
);
2079 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2080 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2081 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2085 /* This is a reference to a symbol defined by a dynamic object which
2086 is not a function. The Alpha, since it uses .got entries for all
2087 symbols even in regular objects, does not need the hackery of a
2088 .dynbss section and COPY dynamic relocations. */
2093 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2096 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
2097 unsigned int st_other
,
2101 if (!dynamic
&& definition
)
2102 h
->other
= ((h
->other
& ELF_ST_VISIBILITY (-1))
2103 | (st_other
& ~ELF_ST_VISIBILITY (-1)));
2106 /* Symbol versioning can create new symbols, and make our old symbols
2107 indirect to the new ones. Consolidate the got and reloc information
2108 in these situations. */
2111 elf64_alpha_copy_indirect_symbol (struct bfd_link_info
*info
,
2112 struct elf_link_hash_entry
*dir
,
2113 struct elf_link_hash_entry
*ind
)
2115 struct alpha_elf_link_hash_entry
*hi
2116 = (struct alpha_elf_link_hash_entry
*) ind
;
2117 struct alpha_elf_link_hash_entry
*hs
2118 = (struct alpha_elf_link_hash_entry
*) dir
;
2120 /* Do the merging in the superclass. */
2121 _bfd_elf_link_hash_copy_indirect(info
, dir
, ind
);
2123 /* Merge the flags. Whee. */
2124 hs
->flags
|= hi
->flags
;
2126 /* ??? It's unclear to me what's really supposed to happen when
2127 "merging" defweak and defined symbols, given that we don't
2128 actually throw away the defweak. This more-or-less copies
2129 the logic related to got and plt entries in the superclass. */
2130 if (ind
->root
.type
!= bfd_link_hash_indirect
)
2133 /* Merge the .got entries. Cannibalize the old symbol's list in
2134 doing so, since we don't need it anymore. */
2136 if (hs
->got_entries
== NULL
)
2137 hs
->got_entries
= hi
->got_entries
;
2140 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
2142 gsh
= hs
->got_entries
;
2143 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
2146 for (gs
= gsh
; gs
; gs
= gs
->next
)
2147 if (gi
->gotobj
== gs
->gotobj
2148 && gi
->reloc_type
== gs
->reloc_type
2149 && gi
->addend
== gs
->addend
)
2151 gs
->use_count
+= gi
->use_count
;
2154 gi
->next
= hs
->got_entries
;
2155 hs
->got_entries
= gi
;
2159 hi
->got_entries
= NULL
;
2161 /* And similar for the reloc entries. */
2163 if (hs
->reloc_entries
== NULL
)
2164 hs
->reloc_entries
= hi
->reloc_entries
;
2167 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
2169 rsh
= hs
->reloc_entries
;
2170 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
2173 for (rs
= rsh
; rs
; rs
= rs
->next
)
2174 if (ri
->rtype
== rs
->rtype
&& ri
->srel
== rs
->srel
)
2176 rs
->count
+= ri
->count
;
2179 ri
->next
= hs
->reloc_entries
;
2180 hs
->reloc_entries
= ri
;
2184 hi
->reloc_entries
= NULL
;
2187 /* Is it possible to merge two object file's .got tables? */
2190 elf64_alpha_can_merge_gots (bfd
*a
, bfd
*b
)
2192 int total
= alpha_elf_tdata (a
)->total_got_size
;
2195 /* Trivial quick fallout test. */
2196 if (total
+ alpha_elf_tdata (b
)->total_got_size
<= MAX_GOT_SIZE
)
2199 /* By their nature, local .got entries cannot be merged. */
2200 if ((total
+= alpha_elf_tdata (b
)->local_got_size
) > MAX_GOT_SIZE
)
2203 /* Failing the common trivial comparison, we must effectively
2204 perform the merge. Not actually performing the merge means that
2205 we don't have to store undo information in case we fail. */
2206 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2208 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
2209 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2212 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
2213 for (i
= 0; i
< n
; ++i
)
2215 struct alpha_elf_got_entry
*ae
, *be
;
2216 struct alpha_elf_link_hash_entry
*h
;
2219 while (h
->root
.root
.type
== bfd_link_hash_indirect
2220 || h
->root
.root
.type
== bfd_link_hash_warning
)
2221 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2223 for (be
= h
->got_entries
; be
; be
= be
->next
)
2225 if (be
->use_count
== 0)
2227 if (be
->gotobj
!= b
)
2230 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
2232 && ae
->reloc_type
== be
->reloc_type
2233 && ae
->addend
== be
->addend
)
2236 total
+= alpha_got_entry_size (be
->reloc_type
);
2237 if (total
> MAX_GOT_SIZE
)
2247 /* Actually merge two .got tables. */
2250 elf64_alpha_merge_gots (bfd
*a
, bfd
*b
)
2252 int total
= alpha_elf_tdata (a
)->total_got_size
;
2255 /* Remember local expansion. */
2257 int e
= alpha_elf_tdata (b
)->local_got_size
;
2259 alpha_elf_tdata (a
)->local_got_size
+= e
;
2262 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2264 struct alpha_elf_got_entry
**local_got_entries
;
2265 struct alpha_elf_link_hash_entry
**hashes
;
2266 Elf_Internal_Shdr
*symtab_hdr
;
2269 /* Let the local .got entries know they are part of a new subsegment. */
2270 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
2271 if (local_got_entries
)
2273 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
2274 for (i
= 0; i
< n
; ++i
)
2276 struct alpha_elf_got_entry
*ent
;
2277 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
2282 /* Merge the global .got entries. */
2283 hashes
= alpha_elf_sym_hashes (bsub
);
2284 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2286 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
2287 for (i
= 0; i
< n
; ++i
)
2289 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
2290 struct alpha_elf_link_hash_entry
*h
;
2293 while (h
->root
.root
.type
== bfd_link_hash_indirect
2294 || h
->root
.root
.type
== bfd_link_hash_warning
)
2295 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2297 pbe
= start
= &h
->got_entries
;
2298 while ((be
= *pbe
) != NULL
)
2300 if (be
->use_count
== 0)
2303 memset (be
, 0xa5, sizeof (*be
));
2306 if (be
->gotobj
!= b
)
2309 for (ae
= *start
; ae
; ae
= ae
->next
)
2311 && ae
->reloc_type
== be
->reloc_type
2312 && ae
->addend
== be
->addend
)
2314 ae
->flags
|= be
->flags
;
2315 ae
->use_count
+= be
->use_count
;
2317 memset (be
, 0xa5, sizeof (*be
));
2321 total
+= alpha_got_entry_size (be
->reloc_type
);
2329 alpha_elf_tdata (bsub
)->gotobj
= a
;
2331 alpha_elf_tdata (a
)->total_got_size
= total
;
2333 /* Merge the two in_got chains. */
2338 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
2341 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
2345 /* Calculate the offsets for the got entries. */
2348 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry
*h
,
2349 void * arg ATTRIBUTE_UNUSED
)
2351 struct alpha_elf_got_entry
*gotent
;
2353 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2354 if (gotent
->use_count
> 0)
2356 struct alpha_elf_obj_tdata
*td
;
2357 bfd_size_type
*plge
;
2359 td
= alpha_elf_tdata (gotent
->gotobj
);
2360 plge
= &td
->got
->size
;
2361 gotent
->got_offset
= *plge
;
2362 *plge
+= alpha_got_entry_size (gotent
->reloc_type
);
2369 elf64_alpha_calc_got_offsets (struct bfd_link_info
*info
)
2372 struct alpha_elf_link_hash_table
* htab
;
2374 htab
= alpha_elf_hash_table (info
);
2377 got_list
= htab
->got_list
;
2379 /* First, zero out the .got sizes, as we may be recalculating the
2380 .got after optimizing it. */
2381 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2382 alpha_elf_tdata(i
)->got
->size
= 0;
2384 /* Next, fill in the offsets for all the global entries. */
2385 alpha_elf_link_hash_traverse (htab
,
2386 elf64_alpha_calc_got_offsets_for_symbol
,
2389 /* Finally, fill in the offsets for the local entries. */
2390 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2392 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->size
;
2395 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
2397 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
2400 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
2401 if (!local_got_entries
)
2404 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
2405 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
2406 if (gotent
->use_count
> 0)
2408 gotent
->got_offset
= got_offset
;
2409 got_offset
+= alpha_got_entry_size (gotent
->reloc_type
);
2413 alpha_elf_tdata(i
)->got
->size
= got_offset
;
2417 /* Constructs the gots. */
2420 elf64_alpha_size_got_sections (struct bfd_link_info
*info
,
2423 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
2424 struct alpha_elf_link_hash_table
* htab
;
2426 htab
= alpha_elf_hash_table (info
);
2429 got_list
= htab
->got_list
;
2431 /* On the first time through, pretend we have an existing got list
2432 consisting of all of the input files. */
2433 if (got_list
== NULL
)
2435 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
2439 if (! is_alpha_elf (i
))
2442 this_got
= alpha_elf_tdata (i
)->gotobj
;
2443 if (this_got
== NULL
)
2446 /* We are assuming no merging has yet occurred. */
2447 BFD_ASSERT (this_got
== i
);
2449 if (alpha_elf_tdata (this_got
)->total_got_size
> MAX_GOT_SIZE
)
2451 /* Yikes! A single object file has too many entries. */
2453 /* xgettext:c-format */
2454 (_("%pB: .got subsegment exceeds 64K (size %d)"),
2455 i
, alpha_elf_tdata (this_got
)->total_got_size
);
2459 if (got_list
== NULL
)
2460 got_list
= this_got
;
2462 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
2463 cur_got_obj
= this_got
;
2466 /* Strange degenerate case of no got references. */
2467 if (got_list
== NULL
)
2470 htab
->got_list
= got_list
;
2473 cur_got_obj
= got_list
;
2474 if (cur_got_obj
== NULL
)
2479 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
2482 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
2484 elf64_alpha_merge_gots (cur_got_obj
, i
);
2486 alpha_elf_tdata(i
)->got
->size
= 0;
2487 i
= alpha_elf_tdata(i
)->got_link_next
;
2488 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
2493 i
= alpha_elf_tdata(i
)->got_link_next
;
2498 /* Once the gots have been merged, fill in the got offsets for
2499 everything therein. */
2500 elf64_alpha_calc_got_offsets (info
);
2506 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry
*h
,
2509 asection
*splt
= (asection
*) data
;
2510 struct alpha_elf_got_entry
*gotent
;
2511 bool saw_one
= false;
2513 /* If we didn't need an entry before, we still don't. */
2514 if (!h
->root
.needs_plt
)
2517 /* For each LITERAL got entry still in use, allocate a plt entry. */
2518 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2519 if (gotent
->reloc_type
== R_ALPHA_LITERAL
2520 && gotent
->use_count
> 0)
2522 if (splt
->size
== 0)
2523 splt
->size
= PLT_HEADER_SIZE
;
2524 gotent
->plt_offset
= splt
->size
;
2525 splt
->size
+= PLT_ENTRY_SIZE
;
2529 /* If there weren't any, there's no longer a need for the PLT entry. */
2531 h
->root
.needs_plt
= false;
2536 /* Called from relax_section to rebuild the PLT in light of potential changes
2537 in the function's status. */
2540 elf64_alpha_size_plt_section (struct bfd_link_info
*info
)
2542 asection
*splt
, *spltrel
, *sgotplt
;
2543 unsigned long entries
;
2544 struct alpha_elf_link_hash_table
* htab
;
2546 htab
= alpha_elf_hash_table (info
);
2550 splt
= elf_hash_table(info
)->splt
;
2556 alpha_elf_link_hash_traverse (htab
,
2557 elf64_alpha_size_plt_section_1
, splt
);
2559 /* Every plt entry requires a JMP_SLOT relocation. */
2560 spltrel
= elf_hash_table(info
)->srelplt
;
2564 if (elf64_alpha_use_secureplt
)
2565 entries
= (splt
->size
- NEW_PLT_HEADER_SIZE
) / NEW_PLT_ENTRY_SIZE
;
2567 entries
= (splt
->size
- OLD_PLT_HEADER_SIZE
) / OLD_PLT_ENTRY_SIZE
;
2569 spltrel
->size
= entries
* sizeof (Elf64_External_Rela
);
2571 /* When using the secureplt, we need two words somewhere in the data
2572 segment for the dynamic linker to tell us where to go. This is the
2573 entire contents of the .got.plt section. */
2574 if (elf64_alpha_use_secureplt
)
2576 sgotplt
= elf_hash_table(info
)->sgotplt
;
2577 sgotplt
->size
= entries
? 16 : 0;
2582 elf64_alpha_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2583 struct bfd_link_info
*info
)
2586 struct alpha_elf_link_hash_table
* htab
;
2588 if (bfd_link_relocatable (info
))
2591 htab
= alpha_elf_hash_table (info
);
2595 if (!elf64_alpha_size_got_sections (info
, true))
2598 /* Allocate space for all of the .got subsections. */
2600 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2602 asection
*s
= alpha_elf_tdata(i
)->got
;
2605 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->size
);
2606 if (s
->contents
== NULL
)
2614 /* The number of dynamic relocations required by a static relocation. */
2617 alpha_dynamic_entries_for_reloc (int r_type
, int dynamic
, int shared
, int pie
)
2621 /* May appear in GOT entries. */
2623 return (dynamic
? 2 : shared
? 1 : 0);
2624 case R_ALPHA_TLSLDM
:
2626 case R_ALPHA_LITERAL
:
2627 return dynamic
|| shared
;
2628 case R_ALPHA_GOTTPREL
:
2629 return dynamic
|| (shared
&& !pie
);
2630 case R_ALPHA_GOTDTPREL
:
2633 /* May appear in data sections. */
2634 case R_ALPHA_REFLONG
:
2635 case R_ALPHA_REFQUAD
:
2636 return dynamic
|| shared
;
2637 case R_ALPHA_TPREL64
:
2638 return dynamic
|| (shared
&& !pie
);
2640 /* Everything else is illegal. We'll issue an error during
2641 relocate_section. */
2647 /* Work out the sizes of the dynamic relocation entries. */
2650 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry
*h
,
2651 struct bfd_link_info
*info
)
2654 struct alpha_elf_reloc_entry
*relent
;
2655 unsigned long entries
;
2657 /* If the symbol was defined as a common symbol in a regular object
2658 file, and there was no definition in any dynamic object, then the
2659 linker will have allocated space for the symbol in a common
2660 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2661 set. This is done for dynamic symbols in
2662 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2663 symbols, somehow. */
2664 if (!h
->root
.def_regular
2665 && h
->root
.ref_regular
2666 && !h
->root
.def_dynamic
2667 && (h
->root
.root
.type
== bfd_link_hash_defined
2668 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2669 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2670 h
->root
.def_regular
= 1;
2672 /* If the symbol is dynamic, we'll need all the relocations in their
2673 natural form. If this is a shared object, and it has been forced
2674 local, we'll need the same number of RELATIVE relocations. */
2675 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
2677 /* If the symbol is a hidden undefined weak, then we never have any
2678 relocations. Avoid the loop which may want to add RELATIVE relocs
2679 based on bfd_link_pic (info). */
2680 if (h
->root
.root
.type
== bfd_link_hash_undefweak
&& !dynamic
)
2683 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
2685 entries
= alpha_dynamic_entries_for_reloc (relent
->rtype
, dynamic
,
2686 bfd_link_pic (info
),
2687 bfd_link_pie (info
));
2690 asection
*sec
= relent
->sec
;
2691 relent
->srel
->size
+=
2692 entries
* sizeof (Elf64_External_Rela
) * relent
->count
;
2693 if ((sec
->flags
& SEC_READONLY
) != 0)
2695 info
->flags
|= DT_TEXTREL
;
2696 info
->callbacks
->minfo
2697 (_("%pB: dynamic relocation against `%pT' in "
2698 "read-only section `%pA'\n"),
2699 sec
->owner
, h
->root
.root
.root
.string
, sec
);
2707 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2711 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry
*h
,
2712 struct bfd_link_info
*info
)
2715 struct alpha_elf_got_entry
*gotent
;
2716 unsigned long entries
;
2718 /* If we're using a plt for this symbol, then all of its relocations
2719 for its got entries go into .rela.plt. */
2720 if (h
->root
.needs_plt
)
2723 /* If the symbol is dynamic, we'll need all the relocations in their
2724 natural form. If this is a shared object, and it has been forced
2725 local, we'll need the same number of RELATIVE relocations. */
2726 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
2728 /* If the symbol is a hidden undefined weak, then we never have any
2729 relocations. Avoid the loop which may want to add RELATIVE relocs
2730 based on bfd_link_pic (info). */
2731 if (h
->root
.root
.type
== bfd_link_hash_undefweak
&& !dynamic
)
2735 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2736 if (gotent
->use_count
> 0)
2737 entries
+= alpha_dynamic_entries_for_reloc (gotent
->reloc_type
, dynamic
,
2738 bfd_link_pic (info
),
2739 bfd_link_pie (info
));
2743 asection
*srel
= elf_hash_table(info
)->srelgot
;
2744 BFD_ASSERT (srel
!= NULL
);
2745 srel
->size
+= sizeof (Elf64_External_Rela
) * entries
;
2751 /* Set the sizes of the dynamic relocation sections. */
2754 elf64_alpha_size_rela_got_section (struct bfd_link_info
*info
)
2756 unsigned long entries
;
2759 struct alpha_elf_link_hash_table
* htab
;
2761 htab
= alpha_elf_hash_table (info
);
2765 /* Shared libraries often require RELATIVE relocs, and some relocs
2766 require attention for the main application as well. */
2769 for (i
= htab
->got_list
;
2770 i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2774 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
2776 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
2779 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
2780 if (!local_got_entries
)
2783 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
2784 for (gotent
= local_got_entries
[k
];
2785 gotent
; gotent
= gotent
->next
)
2786 if (gotent
->use_count
> 0)
2787 entries
+= (alpha_dynamic_entries_for_reloc
2788 (gotent
->reloc_type
, 0, bfd_link_pic (info
),
2789 bfd_link_pie (info
)));
2793 srel
= elf_hash_table(info
)->srelgot
;
2796 BFD_ASSERT (entries
== 0);
2799 srel
->size
= sizeof (Elf64_External_Rela
) * entries
;
2801 /* Now do the non-local symbols. */
2802 alpha_elf_link_hash_traverse (htab
,
2803 elf64_alpha_size_rela_got_1
, info
);
2806 /* Set the sizes of the dynamic sections. */
2809 elf64_alpha_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2810 struct bfd_link_info
*info
)
2814 bool relplt
, relocs
;
2815 struct alpha_elf_link_hash_table
* htab
;
2817 htab
= alpha_elf_hash_table (info
);
2821 dynobj
= elf_hash_table(info
)->dynobj
;
2822 BFD_ASSERT(dynobj
!= NULL
);
2824 if (elf_hash_table (info
)->dynamic_sections_created
)
2826 /* Set the contents of the .interp section to the interpreter. */
2827 if (bfd_link_executable (info
) && !info
->nointerp
)
2829 s
= bfd_get_linker_section (dynobj
, ".interp");
2830 BFD_ASSERT (s
!= NULL
);
2831 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2832 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2835 /* Now that we've seen all of the input files, we can decide which
2836 symbols need dynamic relocation entries and which don't. We've
2837 collected information in check_relocs that we can now apply to
2838 size the dynamic relocation sections. */
2839 alpha_elf_link_hash_traverse (htab
,
2840 elf64_alpha_calc_dynrel_sizes
, info
);
2842 elf64_alpha_size_rela_got_section (info
);
2843 elf64_alpha_size_plt_section (info
);
2845 /* else we're not dynamic and by definition we don't need such things. */
2847 /* The check_relocs and adjust_dynamic_symbol entry points have
2848 determined the sizes of the various dynamic sections. Allocate
2852 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2856 if (!(s
->flags
& SEC_LINKER_CREATED
))
2859 /* It's OK to base decisions on the section name, because none
2860 of the dynobj section names depend upon the input files. */
2861 name
= bfd_section_name (s
);
2863 if (startswith (name
, ".rela"))
2867 if (strcmp (name
, ".rela.plt") == 0)
2872 /* We use the reloc_count field as a counter if we need
2873 to copy relocs into the output file. */
2877 else if (! startswith (name
, ".got")
2878 && strcmp (name
, ".plt") != 0
2879 && strcmp (name
, ".dynbss") != 0)
2881 /* It's not one of our dynamic sections, so don't allocate space. */
2887 /* If we don't need this section, strip it from the output file.
2888 This is to handle .rela.bss and .rela.plt. We must create it
2889 in create_dynamic_sections, because it must be created before
2890 the linker maps input sections to output sections. The
2891 linker does that before adjust_dynamic_symbol is called, and
2892 it is that function which decides whether anything needs to
2893 go into these sections. */
2894 if (!startswith (name
, ".got"))
2895 s
->flags
|= SEC_EXCLUDE
;
2897 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
2899 /* Allocate memory for the section contents. */
2900 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2901 if (s
->contents
== NULL
)
2906 if (elf_hash_table (info
)->dynamic_sections_created
)
2908 /* Add some entries to the .dynamic section. We fill in the
2909 values later, in elf64_alpha_finish_dynamic_sections, but we
2910 must add the entries now so that we get the correct size for
2911 the .dynamic section. The DT_DEBUG entry is filled in by the
2912 dynamic linker and used by the debugger. */
2913 #define add_dynamic_entry(TAG, VAL) \
2914 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2916 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
,
2921 && elf64_alpha_use_secureplt
2922 && !add_dynamic_entry (DT_ALPHA_PLTRO
, 1))
2925 #undef add_dynamic_entry
2930 /* These functions do relaxation for Alpha ELF.
2932 Currently I'm only handling what I can do with existing compiler
2933 and assembler support, which means no instructions are removed,
2934 though some may be nopped. At this time GCC does not emit enough
2935 information to do all of the relaxing that is possible. It will
2936 take some not small amount of work for that to happen.
2938 There are a couple of interesting papers that I once read on this
2939 subject, that I cannot find references to at the moment, that
2940 related to Alpha in particular. They are by David Wall, then of
2943 struct alpha_relax_info
2948 Elf_Internal_Shdr
*symtab_hdr
;
2949 Elf_Internal_Rela
*relocs
, *relend
;
2950 struct bfd_link_info
*link_info
;
2954 struct alpha_elf_link_hash_entry
*h
;
2955 struct alpha_elf_got_entry
**first_gotent
;
2956 struct alpha_elf_got_entry
*gotent
;
2957 bool changed_contents
;
2958 bool changed_relocs
;
2959 unsigned char other
;
2962 static Elf_Internal_Rela
*
2963 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela
*rel
,
2964 Elf_Internal_Rela
*relend
,
2965 bfd_vma offset
, int type
)
2967 while (rel
< relend
)
2969 if (rel
->r_offset
== offset
2970 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
2978 elf64_alpha_relax_got_load (struct alpha_relax_info
*info
, bfd_vma symval
,
2979 Elf_Internal_Rela
*irel
, unsigned long r_type
)
2982 bfd_signed_vma disp
;
2984 /* Get the instruction. */
2985 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
2987 if (insn
>> 26 != OP_LDQ
)
2989 reloc_howto_type
*howto
= elf64_alpha_howto_table
+ r_type
;
2991 /* xgettext:c-format */
2992 (_("%pB: %pA+%#" PRIx64
": warning: "
2993 "%s relocation against unexpected insn"),
2994 info
->abfd
, info
->sec
, (uint64_t) irel
->r_offset
, howto
->name
);
2998 /* Can't relax dynamic symbols. */
3000 && alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
3003 /* Can't use local-exec relocations in shared libraries. */
3004 if (r_type
== R_ALPHA_GOTTPREL
3005 && bfd_link_dll (info
->link_info
))
3008 if (r_type
== R_ALPHA_LITERAL
)
3010 /* Look for nice constant addresses. This includes the not-uncommon
3011 special case of 0 for undefweak symbols. */
3012 if ((info
->h
&& info
->h
->root
.root
.type
== bfd_link_hash_undefweak
)
3013 || (!bfd_link_pic (info
->link_info
)
3014 && (symval
>= (bfd_vma
)-0x8000 || symval
< 0x8000)))
3017 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
3018 insn
|= (symval
& 0xffff);
3019 r_type
= R_ALPHA_NONE
;
3023 /* We may only create GPREL relocs during the second pass. */
3024 if (info
->link_info
->relax_pass
== 0)
3027 disp
= symval
- info
->gp
;
3028 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
3029 r_type
= R_ALPHA_GPREL16
;
3034 bfd_vma dtp_base
, tp_base
;
3036 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
3037 dtp_base
= alpha_get_dtprel_base (info
->link_info
);
3038 tp_base
= alpha_get_tprel_base (info
->link_info
);
3039 disp
= symval
- (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
3041 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
3045 case R_ALPHA_GOTDTPREL
:
3046 r_type
= R_ALPHA_DTPREL16
;
3048 case R_ALPHA_GOTTPREL
:
3049 r_type
= R_ALPHA_TPREL16
;
3057 if (disp
< -0x8000 || disp
>= 0x8000)
3060 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, info
->contents
+ irel
->r_offset
);
3061 info
->changed_contents
= true;
3063 /* Reduce the use count on this got entry by one, possibly
3065 if (--info
->gotent
->use_count
== 0)
3067 int sz
= alpha_got_entry_size (r_type
);
3068 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3070 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
3073 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3074 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), r_type
);
3075 info
->changed_relocs
= true;
3077 /* ??? Search forward through this basic block looking for insns
3078 that use the target register. Stop after an insn modifying the
3079 register is seen, or after a branch or call.
3081 Any such memory load insn may be substituted by a load directly
3082 off the GP. This allows the memory load insn to be issued before
3083 the calculated GP register would otherwise be ready.
3085 Any such jsr insn can be replaced by a bsr if it is in range.
3087 This would mean that we'd have to _add_ relocations, the pain of
3088 which gives one pause. */
3094 elf64_alpha_relax_opt_call (struct alpha_relax_info
*info
, bfd_vma symval
)
3096 /* If the function has the same gp, and we can identify that the
3097 function does not use its function pointer, we can eliminate the
3100 /* If the symbol is marked NOPV, we are being told the function never
3101 needs its procedure value. */
3102 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
3105 /* If the symbol is marked STD_GP, we are being told the function does
3106 a normal ldgp in the first two words. */
3107 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
3110 /* Otherwise, we may be able to identify a GP load in the first two
3111 words, which we can then skip. */
3114 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
3117 /* Load the relocations from the section that the target symbol is in. */
3118 if (info
->sec
== info
->tsec
)
3120 tsec_relocs
= info
->relocs
;
3121 tsec_relend
= info
->relend
;
3126 tsec_relocs
= (_bfd_elf_link_read_relocs
3127 (info
->abfd
, info
->tsec
, NULL
,
3128 (Elf_Internal_Rela
*) NULL
,
3129 info
->link_info
->keep_memory
));
3130 if (tsec_relocs
== NULL
)
3132 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
3133 tsec_free
= (elf_section_data (info
->tsec
)->relocs
== tsec_relocs
3138 /* Recover the symbol's offset within the section. */
3139 ofs
= (symval
- info
->tsec
->output_section
->vma
3140 - info
->tsec
->output_offset
);
3142 /* Look for a GPDISP reloc. */
3143 gpdisp
= (elf64_alpha_find_reloc_at_ofs
3144 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
3146 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
3154 /* We've now determined that we can skip an initial gp load. Verify
3155 that the call and the target use the same gp. */
3156 if (info
->link_info
->output_bfd
->xvec
!= info
->tsec
->owner
->xvec
3157 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
3164 elf64_alpha_relax_with_lituse (struct alpha_relax_info
*info
,
3165 bfd_vma symval
, Elf_Internal_Rela
*irel
)
3167 Elf_Internal_Rela
*urel
, *erel
, *irelend
= info
->relend
;
3169 bfd_signed_vma disp
;
3172 bool lit_reused
= false;
3173 bool all_optimized
= true;
3174 bool changed_contents
;
3175 bool changed_relocs
;
3176 bfd_byte
*contents
= info
->contents
;
3177 bfd
*abfd
= info
->abfd
;
3178 bfd_vma sec_output_vma
;
3179 unsigned int lit_insn
;
3182 lit_insn
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3183 if (lit_insn
>> 26 != OP_LDQ
)
3186 /* xgettext:c-format */
3187 (_("%pB: %pA+%#" PRIx64
": warning: "
3188 "%s relocation against unexpected insn"),
3189 abfd
, info
->sec
, (uint64_t) irel
->r_offset
, "LITERAL");
3193 /* Can't relax dynamic symbols. */
3194 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
3197 changed_contents
= info
->changed_contents
;
3198 changed_relocs
= info
->changed_relocs
;
3199 sec_output_vma
= info
->sec
->output_section
->vma
+ info
->sec
->output_offset
;
3200 relax_pass
= info
->link_info
->relax_pass
;
3202 /* Summarize how this particular LITERAL is used. */
3203 for (erel
= irel
+1, flags
= 0; erel
< irelend
; ++erel
)
3205 if (ELF64_R_TYPE (erel
->r_info
) != R_ALPHA_LITUSE
)
3207 if (erel
->r_addend
<= 6)
3208 flags
|= 1 << erel
->r_addend
;
3211 /* A little preparation for the loop... */
3212 disp
= symval
- info
->gp
;
3214 for (urel
= irel
+1; urel
< erel
; ++urel
)
3216 bfd_vma urel_r_offset
= urel
->r_offset
;
3219 bfd_signed_vma xdisp
;
3220 Elf_Internal_Rela nrel
;
3222 insn
= bfd_get_32 (abfd
, contents
+ urel_r_offset
);
3224 switch (urel
->r_addend
)
3226 case LITUSE_ALPHA_ADDR
:
3228 /* This type is really just a placeholder to note that all
3229 uses cannot be optimized, but to still allow some. */
3230 all_optimized
= false;
3233 case LITUSE_ALPHA_BASE
:
3234 /* We may only create GPREL relocs during the second pass. */
3235 if (relax_pass
== 0)
3237 all_optimized
= false;
3241 /* We can always optimize 16-bit displacements. */
3243 /* Extract the displacement from the instruction, sign-extending
3244 it if necessary, then test whether it is within 16 or 32 bits
3245 displacement from GP. */
3246 insn_disp
= ((insn
& 0xffff) ^ 0x8000) - 0x8000;
3248 xdisp
= disp
+ insn_disp
;
3249 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x8000 && xdisp
< 0x8000);
3250 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000
3251 && xdisp
< 0x7fff8000);
3255 /* Take the op code and dest from this insn, take the base
3256 register from the literal insn. Leave the offset alone. */
3257 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
3258 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3259 changed_contents
= true;
3262 nrel
.r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3264 nrel
.r_addend
= irel
->r_addend
;
3266 /* As we adjust, move the reloc to the end so that we don't
3267 break the LITERAL+LITUSE chain. */
3271 changed_relocs
= true;
3274 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3275 else if (fits32
&& !(flags
& ~6))
3277 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3279 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3281 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
3282 bfd_put_32 (abfd
, (bfd_vma
) lit_insn
, contents
+ irel
->r_offset
);
3284 changed_contents
= true;
3286 /* Since all relocs must be optimized, don't bother swapping
3287 this relocation to the end. */
3288 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3290 urel
->r_addend
= irel
->r_addend
;
3291 changed_relocs
= true;
3294 all_optimized
= false;
3297 case LITUSE_ALPHA_BYTOFF
:
3298 /* We can always optimize byte instructions. */
3300 /* FIXME: sanity check the insn for byte op. Check that the
3301 literal dest reg is indeed Rb in the byte insn. */
3303 insn
&= ~ (unsigned) 0x001ff000;
3304 insn
|= ((symval
& 7) << 13) | 0x1000;
3305 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3306 changed_contents
= true;
3309 nrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3312 /* As we adjust, move the reloc to the end so that we don't
3313 break the LITERAL+LITUSE chain. */
3317 changed_relocs
= true;
3320 case LITUSE_ALPHA_JSR
:
3321 case LITUSE_ALPHA_TLSGD
:
3322 case LITUSE_ALPHA_TLSLDM
:
3323 case LITUSE_ALPHA_JSRDIRECT
:
3325 bfd_vma optdest
, org
;
3326 bfd_signed_vma odisp
;
3328 /* For undefined weak symbols, we're mostly interested in getting
3329 rid of the got entry whenever possible, so optimize this to a
3330 use of the zero register. */
3331 if (info
->h
&& info
->h
->root
.root
.type
== bfd_link_hash_undefweak
)
3334 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3336 changed_contents
= true;
3340 /* If not zero, place to jump without needing pv. */
3341 optdest
= elf64_alpha_relax_opt_call (info
, symval
);
3342 org
= sec_output_vma
+ urel_r_offset
+ 4;
3343 odisp
= (optdest
? optdest
: symval
) - org
;
3345 if (odisp
>= -0x400000 && odisp
< 0x400000)
3347 Elf_Internal_Rela
*xrel
;
3349 /* Preserve branch prediction call stack when possible. */
3350 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
3351 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
3353 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
3354 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3355 changed_contents
= true;
3358 nrel
.r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3360 nrel
.r_addend
= irel
->r_addend
;
3363 nrel
.r_addend
+= optdest
- symval
;
3365 all_optimized
= false;
3367 /* Kill any HINT reloc that might exist for this insn. */
3368 xrel
= (elf64_alpha_find_reloc_at_ofs
3369 (info
->relocs
, info
->relend
, urel_r_offset
,
3372 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3374 /* As we adjust, move the reloc to the end so that we don't
3375 break the LITERAL+LITUSE chain. */
3380 info
->changed_relocs
= true;
3383 all_optimized
= false;
3385 /* Even if the target is not in range for a direct branch,
3386 if we share a GP, we can eliminate the gp reload. */
3389 Elf_Internal_Rela
*gpdisp
3390 = (elf64_alpha_find_reloc_at_ofs
3391 (info
->relocs
, irelend
, urel_r_offset
+ 4,
3395 bfd_byte
*p_ldah
= contents
+ gpdisp
->r_offset
;
3396 bfd_byte
*p_lda
= p_ldah
+ gpdisp
->r_addend
;
3397 unsigned int ldah
= bfd_get_32 (abfd
, p_ldah
);
3398 unsigned int lda
= bfd_get_32 (abfd
, p_lda
);
3400 /* Verify that the instruction is "ldah $29,0($26)".
3401 Consider a function that ends in a noreturn call,
3402 and that the next function begins with an ldgp,
3403 and that by accident there is no padding between.
3404 In that case the insn would use $27 as the base. */
3405 if (ldah
== 0x27ba0000 && lda
== 0x23bd0000)
3407 bfd_put_32 (abfd
, (bfd_vma
) INSN_UNOP
, p_ldah
);
3408 bfd_put_32 (abfd
, (bfd_vma
) INSN_UNOP
, p_lda
);
3410 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3411 changed_contents
= true;
3412 changed_relocs
= true;
3421 /* If we reused the literal instruction, we must have optimized all. */
3422 BFD_ASSERT(!lit_reused
|| all_optimized
);
3424 /* If all cases were optimized, we can reduce the use count on this
3425 got entry by one, possibly eliminating it. */
3428 if (--info
->gotent
->use_count
== 0)
3430 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
3431 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3433 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
3436 /* If the literal instruction is no longer needed (it may have been
3437 reused. We can eliminate it. */
3438 /* ??? For now, I don't want to deal with compacting the section,
3439 so just nop it out. */
3442 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3443 changed_relocs
= true;
3445 bfd_put_32 (abfd
, (bfd_vma
) INSN_UNOP
, contents
+ irel
->r_offset
);
3446 changed_contents
= true;
3450 info
->changed_contents
= changed_contents
;
3451 info
->changed_relocs
= changed_relocs
;
3453 if (all_optimized
|| relax_pass
== 0)
3455 return elf64_alpha_relax_got_load (info
, symval
, irel
, R_ALPHA_LITERAL
);
3459 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info
*info
, bfd_vma symval
,
3460 Elf_Internal_Rela
*irel
, bool is_gd
)
3463 unsigned int insn
, tlsgd_reg
;
3464 Elf_Internal_Rela
*gpdisp
, *hint
;
3465 bool dynamic
, use_gottprel
;
3466 unsigned long new_symndx
;
3468 dynamic
= (info
->h
!= NULL
3469 && alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
));
3471 /* If a TLS symbol is accessed using IE at least once, there is no point
3472 to use dynamic model for it. */
3473 if (is_gd
&& info
->h
&& (info
->h
->flags
& ALPHA_ELF_LINK_HASH_TLS_IE
))
3476 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3477 then we might as well relax to IE. */
3478 else if (bfd_link_pic (info
->link_info
) && !dynamic
3479 && (info
->link_info
->flags
& DF_STATIC_TLS
))
3482 /* Otherwise we must be building an executable to do anything. */
3483 else if (bfd_link_pic (info
->link_info
))
3486 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3487 the matching LITUSE_TLS relocations. */
3488 if (irel
+ 2 >= info
->relend
)
3490 if (ELF64_R_TYPE (irel
[1].r_info
) != R_ALPHA_LITERAL
3491 || ELF64_R_TYPE (irel
[2].r_info
) != R_ALPHA_LITUSE
3492 || irel
[2].r_addend
!= (is_gd
? LITUSE_ALPHA_TLSGD
: LITUSE_ALPHA_TLSLDM
))
3495 /* There must be a GPDISP relocation positioned immediately after the
3496 LITUSE relocation. */
3497 gpdisp
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
3498 irel
[2].r_offset
+ 4, R_ALPHA_GPDISP
);
3502 pos
[0] = info
->contents
+ irel
[0].r_offset
;
3503 pos
[1] = info
->contents
+ irel
[1].r_offset
;
3504 pos
[2] = info
->contents
+ irel
[2].r_offset
;
3505 pos
[3] = info
->contents
+ gpdisp
->r_offset
;
3506 pos
[4] = pos
[3] + gpdisp
->r_addend
;
3508 /* Beware of the compiler hoisting part of the sequence out a loop
3509 and adjusting the destination register for the TLSGD insn. If this
3510 happens, there will be a move into $16 before the JSR insn, so only
3511 transformations of the first insn pair should use this register. */
3512 tlsgd_reg
= bfd_get_32 (info
->abfd
, pos
[0]);
3513 tlsgd_reg
= (tlsgd_reg
>> 21) & 31;
3515 /* Generally, the positions are not allowed to be out of order, lest the
3516 modified insn sequence have different register lifetimes. We can make
3517 an exception when pos 1 is adjacent to pos 0. */
3518 if (pos
[1] + 4 == pos
[0])
3520 bfd_byte
*tmp
= pos
[0];
3524 if (pos
[1] >= pos
[2] || pos
[2] >= pos
[3])
3527 /* Reduce the use count on the LITERAL relocation. Do this before we
3528 smash the symndx when we adjust the relocations below. */
3530 struct alpha_elf_got_entry
*lit_gotent
;
3531 struct alpha_elf_link_hash_entry
*lit_h
;
3534 BFD_ASSERT (ELF64_R_SYM (irel
[1].r_info
) >= info
->symtab_hdr
->sh_info
);
3535 indx
= ELF64_R_SYM (irel
[1].r_info
) - info
->symtab_hdr
->sh_info
;
3536 lit_h
= alpha_elf_sym_hashes (info
->abfd
)[indx
];
3538 while (lit_h
->root
.root
.type
== bfd_link_hash_indirect
3539 || lit_h
->root
.root
.type
== bfd_link_hash_warning
)
3540 lit_h
= (struct alpha_elf_link_hash_entry
*) lit_h
->root
.root
.u
.i
.link
;
3542 for (lit_gotent
= lit_h
->got_entries
; lit_gotent
;
3543 lit_gotent
= lit_gotent
->next
)
3544 if (lit_gotent
->gotobj
== info
->gotobj
3545 && lit_gotent
->reloc_type
== R_ALPHA_LITERAL
3546 && lit_gotent
->addend
== irel
[1].r_addend
)
3548 BFD_ASSERT (lit_gotent
);
3550 if (--lit_gotent
->use_count
== 0)
3552 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
3553 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3559 lda $16,x($gp) !tlsgd!1
3560 ldq $27,__tls_get_addr($gp) !literal!1
3561 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3562 ldah $29,0($26) !gpdisp!2
3563 lda $29,0($29) !gpdisp!2
3565 ldq $16,x($gp) !gottprel
3570 or the first pair to
3571 lda $16,x($gp) !tprel
3574 ldah $16,x($gp) !tprelhi
3575 lda $16,x($16) !tprello
3579 use_gottprel
= false;
3580 new_symndx
= is_gd
? ELF64_R_SYM (irel
->r_info
) : STN_UNDEF
;
3582 /* Some compilers warn about a Boolean-looking expression being
3583 used in a switch. The explicit cast silences them. */
3584 switch ((int) (!dynamic
&& !bfd_link_pic (info
->link_info
)))
3589 bfd_signed_vma disp
;
3591 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
3592 tp_base
= alpha_get_tprel_base (info
->link_info
);
3593 disp
= symval
- tp_base
;
3595 if (disp
>= -0x8000 && disp
< 0x8000)
3597 insn
= (OP_LDA
<< 26) | (tlsgd_reg
<< 21) | (31 << 16);
3598 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
3599 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
3601 irel
[0].r_offset
= pos
[0] - info
->contents
;
3602 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPREL16
);
3603 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3606 else if (disp
>= -(bfd_signed_vma
) 0x80000000
3607 && disp
< (bfd_signed_vma
) 0x7fff8000
3608 && pos
[0] + 4 == pos
[1])
3610 insn
= (OP_LDAH
<< 26) | (tlsgd_reg
<< 21) | (31 << 16);
3611 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
3612 insn
= (OP_LDA
<< 26) | (tlsgd_reg
<< 21) | (tlsgd_reg
<< 16);
3613 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[1]);
3615 irel
[0].r_offset
= pos
[0] - info
->contents
;
3616 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELHI
);
3617 irel
[1].r_offset
= pos
[1] - info
->contents
;
3618 irel
[1].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELLO
);
3625 use_gottprel
= true;
3627 insn
= (OP_LDQ
<< 26) | (tlsgd_reg
<< 21) | (29 << 16);
3628 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
3629 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
3631 irel
[0].r_offset
= pos
[0] - info
->contents
;
3632 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_GOTTPREL
);
3633 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3637 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_RDUNIQ
, pos
[2]);
3639 insn
= INSN_ADDQ
| (16 << 21) | (0 << 16) | (0 << 0);
3640 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[3]);
3642 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[4]);
3644 irel
[2].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3645 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3647 hint
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
3648 irel
[2].r_offset
, R_ALPHA_HINT
);
3650 hint
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3652 info
->changed_contents
= true;
3653 info
->changed_relocs
= true;
3655 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3656 if (--info
->gotent
->use_count
== 0)
3658 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
3659 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3661 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
3664 /* If we've switched to a GOTTPREL relocation, increment the reference
3665 count on that got entry. */
3668 struct alpha_elf_got_entry
*tprel_gotent
;
3670 for (tprel_gotent
= *info
->first_gotent
; tprel_gotent
;
3671 tprel_gotent
= tprel_gotent
->next
)
3672 if (tprel_gotent
->gotobj
== info
->gotobj
3673 && tprel_gotent
->reloc_type
== R_ALPHA_GOTTPREL
3674 && tprel_gotent
->addend
== irel
->r_addend
)
3677 tprel_gotent
->use_count
++;
3680 if (info
->gotent
->use_count
== 0)
3681 tprel_gotent
= info
->gotent
;
3684 tprel_gotent
= (struct alpha_elf_got_entry
*)
3685 bfd_alloc (info
->abfd
, sizeof (struct alpha_elf_got_entry
));
3689 tprel_gotent
->next
= *info
->first_gotent
;
3690 *info
->first_gotent
= tprel_gotent
;
3692 tprel_gotent
->gotobj
= info
->gotobj
;
3693 tprel_gotent
->addend
= irel
->r_addend
;
3694 tprel_gotent
->got_offset
= -1;
3695 tprel_gotent
->reloc_done
= 0;
3696 tprel_gotent
->reloc_xlated
= 0;
3699 tprel_gotent
->use_count
= 1;
3700 tprel_gotent
->reloc_type
= R_ALPHA_GOTTPREL
;
3708 elf64_alpha_relax_section (bfd
*abfd
, asection
*sec
,
3709 struct bfd_link_info
*link_info
, bool *again
)
3711 Elf_Internal_Shdr
*symtab_hdr
;
3712 Elf_Internal_Rela
*internal_relocs
;
3713 Elf_Internal_Rela
*irel
, *irelend
;
3714 Elf_Internal_Sym
*isymbuf
= NULL
;
3715 struct alpha_elf_got_entry
**local_got_entries
;
3716 struct alpha_relax_info info
;
3717 struct alpha_elf_link_hash_table
* htab
;
3720 htab
= alpha_elf_hash_table (link_info
);
3724 /* There's nothing to change, yet. */
3727 if (bfd_link_relocatable (link_info
)
3728 || ((sec
->flags
& (SEC_CODE
| SEC_RELOC
| SEC_ALLOC
))
3729 != (SEC_CODE
| SEC_RELOC
| SEC_ALLOC
))
3730 || sec
->reloc_count
== 0)
3733 BFD_ASSERT (is_alpha_elf (abfd
));
3734 relax_pass
= link_info
->relax_pass
;
3736 /* Make sure our GOT and PLT tables are up-to-date. */
3737 if (htab
->relax_trip
!= link_info
->relax_trip
)
3739 htab
->relax_trip
= link_info
->relax_trip
;
3741 /* This should never fail after the initial round, since the only error
3742 is GOT overflow, and relaxation only shrinks the table. However, we
3743 may only merge got sections during the first pass. If we merge
3744 sections after we've created GPREL relocs, the GP for the merged
3745 section backs up which may put the relocs out of range. */
3746 if (!elf64_alpha_size_got_sections (link_info
, relax_pass
== 0))
3748 if (elf_hash_table (link_info
)->dynamic_sections_created
)
3750 elf64_alpha_size_plt_section (link_info
);
3751 elf64_alpha_size_rela_got_section (link_info
);
3755 symtab_hdr
= &elf_symtab_hdr (abfd
);
3756 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
3758 /* Load the relocations for this section. */
3759 internal_relocs
= (_bfd_elf_link_read_relocs
3760 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3761 link_info
->keep_memory
));
3762 if (internal_relocs
== NULL
)
3765 memset(&info
, 0, sizeof (info
));
3768 info
.link_info
= link_info
;
3769 info
.symtab_hdr
= symtab_hdr
;
3770 info
.relocs
= internal_relocs
;
3771 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
3773 /* Find the GP for this object. Do not store the result back via
3774 _bfd_set_gp_value, since this could change again before final. */
3775 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
3778 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
3779 info
.gp
= (sgot
->output_section
->vma
3780 + sgot
->output_offset
3784 /* Get the section contents. */
3785 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3786 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
3789 if (!bfd_malloc_and_get_section (abfd
, sec
, &info
.contents
))
3793 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3796 struct alpha_elf_got_entry
*gotent
;
3797 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
3798 unsigned long r_symndx
= ELF64_R_SYM (irel
->r_info
);
3800 /* Early exit for unhandled or unrelaxable relocations. */
3801 if (r_type
!= R_ALPHA_LITERAL
)
3803 /* We complete everything except LITERAL in the first pass. */
3804 if (relax_pass
!= 0)
3806 if (r_type
== R_ALPHA_TLSLDM
)
3808 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3809 reloc to the STN_UNDEF (0) symbol so that they all match. */
3810 r_symndx
= STN_UNDEF
;
3812 else if (r_type
!= R_ALPHA_GOTDTPREL
3813 && r_type
!= R_ALPHA_GOTTPREL
3814 && r_type
!= R_ALPHA_TLSGD
)
3818 /* Get the value of the symbol referred to by the reloc. */
3819 if (r_symndx
< symtab_hdr
->sh_info
)
3821 /* A local symbol. */
3822 Elf_Internal_Sym
*isym
;
3824 /* Read this BFD's local symbols. */
3825 if (isymbuf
== NULL
)
3827 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3828 if (isymbuf
== NULL
)
3829 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3830 symtab_hdr
->sh_info
, 0,
3832 if (isymbuf
== NULL
)
3836 isym
= isymbuf
+ r_symndx
;
3838 /* Given the symbol for a TLSLDM reloc is ignored, this also
3839 means forcing the symbol value to the tp base. */
3840 if (r_type
== R_ALPHA_TLSLDM
)
3842 info
.tsec
= bfd_abs_section_ptr
;
3843 symval
= alpha_get_tprel_base (info
.link_info
);
3847 symval
= isym
->st_value
;
3848 if (isym
->st_shndx
== SHN_UNDEF
)
3850 else if (isym
->st_shndx
== SHN_ABS
)
3851 info
.tsec
= bfd_abs_section_ptr
;
3852 else if (isym
->st_shndx
== SHN_COMMON
)
3853 info
.tsec
= bfd_com_section_ptr
;
3855 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3859 info
.other
= isym
->st_other
;
3860 if (local_got_entries
)
3861 info
.first_gotent
= &local_got_entries
[r_symndx
];
3864 info
.first_gotent
= &info
.gotent
;
3871 struct alpha_elf_link_hash_entry
*h
;
3873 indx
= r_symndx
- symtab_hdr
->sh_info
;
3874 h
= alpha_elf_sym_hashes (abfd
)[indx
];
3875 BFD_ASSERT (h
!= NULL
);
3877 while (h
->root
.root
.type
== bfd_link_hash_indirect
3878 || h
->root
.root
.type
== bfd_link_hash_warning
)
3879 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3881 /* If the symbol is undefined, we can't do anything with it. */
3882 if (h
->root
.root
.type
== bfd_link_hash_undefined
)
3885 /* If the symbol isn't defined in the current module,
3886 again we can't do anything. */
3887 if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3889 info
.tsec
= bfd_abs_section_ptr
;
3892 else if (!h
->root
.def_regular
)
3894 /* Except for TLSGD relocs, which can sometimes be
3895 relaxed to GOTTPREL relocs. */
3896 if (r_type
!= R_ALPHA_TLSGD
)
3898 info
.tsec
= bfd_abs_section_ptr
;
3903 info
.tsec
= h
->root
.root
.u
.def
.section
;
3904 symval
= h
->root
.root
.u
.def
.value
;
3908 info
.other
= h
->root
.other
;
3909 info
.first_gotent
= &h
->got_entries
;
3912 /* Search for the got entry to be used by this relocation. */
3913 for (gotent
= *info
.first_gotent
; gotent
; gotent
= gotent
->next
)
3914 if (gotent
->gotobj
== info
.gotobj
3915 && gotent
->reloc_type
== r_type
3916 && gotent
->addend
== irel
->r_addend
)
3918 info
.gotent
= gotent
;
3920 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
3921 symval
+= irel
->r_addend
;
3925 case R_ALPHA_LITERAL
:
3926 BFD_ASSERT(info
.gotent
!= NULL
);
3928 /* If there exist LITUSE relocations immediately following, this
3929 opens up all sorts of interesting optimizations, because we
3930 now know every location that this address load is used. */
3931 if (irel
+1 < irelend
3932 && ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
3934 if (!elf64_alpha_relax_with_lituse (&info
, symval
, irel
))
3939 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
3944 case R_ALPHA_GOTDTPREL
:
3945 case R_ALPHA_GOTTPREL
:
3946 BFD_ASSERT(info
.gotent
!= NULL
);
3947 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
3952 case R_ALPHA_TLSLDM
:
3953 BFD_ASSERT(info
.gotent
!= NULL
);
3954 if (!elf64_alpha_relax_tls_get_addr (&info
, symval
, irel
,
3955 r_type
== R_ALPHA_TLSGD
))
3962 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3964 if (!link_info
->keep_memory
)
3968 /* Cache the symbols for elf_link_input_bfd. */
3969 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3973 if (info
.contents
!= NULL
3974 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
3976 if (!info
.changed_contents
&& !link_info
->keep_memory
)
3977 free (info
.contents
);
3980 /* Cache the section contents for elf_link_input_bfd. */
3981 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
3985 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
3987 if (!info
.changed_relocs
)
3988 free (internal_relocs
);
3990 elf_section_data (sec
)->relocs
= internal_relocs
;
3993 *again
= info
.changed_contents
|| info
.changed_relocs
;
3998 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
4000 if (elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
4001 free (info
.contents
);
4002 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
4003 free (internal_relocs
);
4007 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4008 into the next available slot in SREL. */
4011 elf64_alpha_emit_dynrel (bfd
*abfd
, struct bfd_link_info
*info
,
4012 asection
*sec
, asection
*srel
, bfd_vma offset
,
4013 long dynindx
, long rtype
, bfd_vma addend
)
4015 Elf_Internal_Rela outrel
;
4018 BFD_ASSERT (srel
!= NULL
);
4020 outrel
.r_info
= ELF64_R_INFO (dynindx
, rtype
);
4021 outrel
.r_addend
= addend
;
4023 offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
4024 if ((offset
| 1) != (bfd_vma
) -1)
4025 outrel
.r_offset
= sec
->output_section
->vma
+ sec
->output_offset
+ offset
;
4027 memset (&outrel
, 0, sizeof (outrel
));
4029 loc
= srel
->contents
;
4030 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
4031 bfd_elf64_swap_reloca_out (abfd
, &outrel
, loc
);
4032 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
<= srel
->size
);
4035 /* Relocate an Alpha ELF section for a relocatable link.
4037 We don't have to change anything unless the reloc is against a section
4038 symbol, in which case we have to adjust according to where the section
4039 symbol winds up in the output section. */
4042 elf64_alpha_relocate_section_r (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4043 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4044 bfd
*input_bfd
, asection
*input_section
,
4045 bfd_byte
*contents ATTRIBUTE_UNUSED
,
4046 Elf_Internal_Rela
*relocs
,
4047 Elf_Internal_Sym
*local_syms
,
4048 asection
**local_sections
)
4050 unsigned long symtab_hdr_sh_info
;
4051 Elf_Internal_Rela
*rel
;
4052 Elf_Internal_Rela
*relend
;
4053 struct elf_link_hash_entry
**sym_hashes
;
4054 bool ret_val
= true;
4056 symtab_hdr_sh_info
= elf_symtab_hdr (input_bfd
).sh_info
;
4057 sym_hashes
= elf_sym_hashes (input_bfd
);
4059 relend
= relocs
+ input_section
->reloc_count
;
4060 for (rel
= relocs
; rel
< relend
; rel
++)
4062 unsigned long r_symndx
;
4063 Elf_Internal_Sym
*sym
;
4065 unsigned long r_type
;
4067 r_type
= ELF64_R_TYPE (rel
->r_info
);
4068 if (r_type
>= R_ALPHA_max
)
4071 /* xgettext:c-format */
4072 (_("%pB: unsupported relocation type %#x"),
4073 input_bfd
, (int) r_type
);
4074 bfd_set_error (bfd_error_bad_value
);
4079 /* The symbol associated with GPDISP and LITUSE is
4080 immaterial. Only the addend is significant. */
4081 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
4084 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4085 if (r_symndx
< symtab_hdr_sh_info
)
4087 sym
= local_syms
+ r_symndx
;
4088 sec
= local_sections
[r_symndx
];
4092 struct elf_link_hash_entry
*h
;
4094 h
= sym_hashes
[r_symndx
- symtab_hdr_sh_info
];
4096 while (h
->root
.type
== bfd_link_hash_indirect
4097 || h
->root
.type
== bfd_link_hash_warning
)
4098 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4100 if (h
->root
.type
!= bfd_link_hash_defined
4101 && h
->root
.type
!= bfd_link_hash_defweak
)
4105 sec
= h
->root
.u
.def
.section
;
4108 if (sec
!= NULL
&& discarded_section (sec
))
4109 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
4111 elf64_alpha_howto_table
+ r_type
, 0,
4114 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4115 rel
->r_addend
+= sec
->output_offset
;
4121 /* Relocate an Alpha ELF section. */
4124 elf64_alpha_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
4125 bfd
*input_bfd
, asection
*input_section
,
4126 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
4127 Elf_Internal_Sym
*local_syms
,
4128 asection
**local_sections
)
4130 Elf_Internal_Shdr
*symtab_hdr
;
4131 Elf_Internal_Rela
*rel
;
4132 Elf_Internal_Rela
*relend
;
4133 asection
*sgot
, *srel
, *srelgot
;
4134 bfd
*dynobj
, *gotobj
;
4135 bfd_vma gp
, tp_base
, dtp_base
;
4136 struct alpha_elf_got_entry
**local_got_entries
;
4139 BFD_ASSERT (is_alpha_elf (input_bfd
));
4141 /* Handle relocatable links with a smaller loop. */
4142 if (bfd_link_relocatable (info
))
4143 return elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
,
4144 input_section
, contents
, relocs
,
4145 local_syms
, local_sections
);
4147 /* This is a final link. */
4151 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4153 dynobj
= elf_hash_table (info
)->dynobj
;
4154 srelgot
= elf_hash_table (info
)->srelgot
;
4156 if (input_section
->flags
& SEC_ALLOC
)
4158 const char *section_name
;
4159 section_name
= (bfd_elf_string_from_elf_section
4160 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
4161 _bfd_elf_single_rel_hdr (input_section
)->sh_name
));
4162 BFD_ASSERT(section_name
!= NULL
);
4163 srel
= bfd_get_linker_section (dynobj
, section_name
);
4168 /* Find the gp value for this input bfd. */
4169 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
4172 sgot
= alpha_elf_tdata (gotobj
)->got
;
4173 gp
= _bfd_get_gp_value (gotobj
);
4176 gp
= (sgot
->output_section
->vma
4177 + sgot
->output_offset
4179 _bfd_set_gp_value (gotobj
, gp
);
4188 local_got_entries
= alpha_elf_tdata(input_bfd
)->local_got_entries
;
4190 if (elf_hash_table (info
)->tls_sec
!= NULL
)
4192 dtp_base
= alpha_get_dtprel_base (info
);
4193 tp_base
= alpha_get_tprel_base (info
);
4196 dtp_base
= tp_base
= 0;
4198 relend
= relocs
+ input_section
->reloc_count
;
4199 for (rel
= relocs
; rel
< relend
; rel
++)
4201 struct alpha_elf_link_hash_entry
*h
= NULL
;
4202 struct alpha_elf_got_entry
*gotent
;
4203 bfd_reloc_status_type r
;
4204 reloc_howto_type
*howto
;
4205 unsigned long r_symndx
;
4206 Elf_Internal_Sym
*sym
= NULL
;
4207 asection
*sec
= NULL
;
4210 bool dynamic_symbol_p
;
4211 bool unresolved_reloc
= false;
4212 bool undef_weak_ref
= false;
4213 unsigned long r_type
;
4215 r_type
= ELF64_R_TYPE(rel
->r_info
);
4216 if (r_type
>= R_ALPHA_max
)
4219 /* xgettext:c-format */
4220 (_("%pB: unsupported relocation type %#x"),
4221 input_bfd
, (int) r_type
);
4222 bfd_set_error (bfd_error_bad_value
);
4227 howto
= elf64_alpha_howto_table
+ r_type
;
4228 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4230 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4231 reloc to the STN_UNDEF (0) symbol so that they all match. */
4232 if (r_type
== R_ALPHA_TLSLDM
)
4233 r_symndx
= STN_UNDEF
;
4235 if (r_symndx
< symtab_hdr
->sh_info
)
4238 sym
= local_syms
+ r_symndx
;
4239 sec
= local_sections
[r_symndx
];
4241 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
4243 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4244 this is hackery from relax_section. Force the value to
4245 be the tls module base. */
4246 if (r_symndx
== STN_UNDEF
4247 && (r_type
== R_ALPHA_TLSLDM
4248 || r_type
== R_ALPHA_GOTTPREL
4249 || r_type
== R_ALPHA_TPREL64
4250 || r_type
== R_ALPHA_TPRELHI
4251 || r_type
== R_ALPHA_TPRELLO
4252 || r_type
== R_ALPHA_TPREL16
))
4255 if (local_got_entries
)
4256 gotent
= local_got_entries
[r_symndx
];
4260 /* Need to adjust local GOT entries' addends for SEC_MERGE
4261 unless it has been done already. */
4262 if ((sec
->flags
& SEC_MERGE
)
4263 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
4264 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4266 && !gotent
->reloc_xlated
)
4268 struct alpha_elf_got_entry
*ent
;
4270 for (ent
= gotent
; ent
; ent
= ent
->next
)
4272 ent
->reloc_xlated
= 1;
4273 if (ent
->use_count
== 0)
4277 _bfd_merged_section_offset (output_bfd
, &msec
,
4278 elf_section_data (sec
)->
4280 sym
->st_value
+ ent
->addend
);
4281 ent
->addend
-= sym
->st_value
;
4282 ent
->addend
+= msec
->output_section
->vma
4283 + msec
->output_offset
4284 - sec
->output_section
->vma
4285 - sec
->output_offset
;
4289 dynamic_symbol_p
= false;
4293 bool warned
, ignored
;
4294 struct elf_link_hash_entry
*hh
;
4295 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
4297 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4298 r_symndx
, symtab_hdr
, sym_hashes
,
4300 unresolved_reloc
, warned
, ignored
);
4306 && ! unresolved_reloc
4307 && hh
->root
.type
== bfd_link_hash_undefweak
)
4308 undef_weak_ref
= true;
4310 h
= (struct alpha_elf_link_hash_entry
*) hh
;
4311 dynamic_symbol_p
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
4312 gotent
= h
->got_entries
;
4315 if (sec
!= NULL
&& discarded_section (sec
))
4316 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
4317 rel
, 1, relend
, howto
, 0, contents
);
4319 addend
= rel
->r_addend
;
4322 /* Search for the proper got entry. */
4323 for (; gotent
; gotent
= gotent
->next
)
4324 if (gotent
->gotobj
== gotobj
4325 && gotent
->reloc_type
== r_type
4326 && gotent
->addend
== addend
)
4331 case R_ALPHA_GPDISP
:
4333 bfd_byte
*p_ldah
, *p_lda
;
4335 BFD_ASSERT(gp
!= 0);
4337 value
= (input_section
->output_section
->vma
4338 + input_section
->output_offset
4341 p_ldah
= contents
+ rel
->r_offset
;
4342 p_lda
= p_ldah
+ rel
->r_addend
;
4344 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- value
,
4349 case R_ALPHA_LITERAL
:
4350 BFD_ASSERT(sgot
!= NULL
);
4351 BFD_ASSERT(gp
!= 0);
4352 BFD_ASSERT(gotent
!= NULL
);
4353 BFD_ASSERT(gotent
->use_count
>= 1);
4355 if (!gotent
->reloc_done
)
4357 gotent
->reloc_done
= 1;
4359 bfd_put_64 (output_bfd
, value
,
4360 sgot
->contents
+ gotent
->got_offset
);
4362 /* If the symbol has been forced local, output a
4363 RELATIVE reloc, otherwise it will be handled in
4364 finish_dynamic_symbol. */
4365 if (bfd_link_pic (info
)
4366 && !dynamic_symbol_p
4368 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4369 gotent
->got_offset
, 0,
4370 R_ALPHA_RELATIVE
, value
);
4373 value
= (sgot
->output_section
->vma
4374 + sgot
->output_offset
4375 + gotent
->got_offset
);
4379 case R_ALPHA_GPREL32
:
4380 case R_ALPHA_GPREL16
:
4381 case R_ALPHA_GPRELLOW
:
4382 if (dynamic_symbol_p
)
4385 /* xgettext:c-format */
4386 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4387 input_bfd
, h
->root
.root
.root
.string
);
4390 BFD_ASSERT(gp
!= 0);
4394 case R_ALPHA_GPRELHIGH
:
4395 if (dynamic_symbol_p
)
4398 /* xgettext:c-format */
4399 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4400 input_bfd
, h
->root
.root
.root
.string
);
4403 BFD_ASSERT(gp
!= 0);
4405 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4409 /* A call to a dynamic symbol is definitely out of range of
4410 the 16-bit displacement. Don't bother writing anything. */
4411 if (dynamic_symbol_p
)
4416 /* The regular PC-relative stuff measures from the start of
4417 the instruction rather than the end. */
4421 case R_ALPHA_BRADDR
:
4422 if (dynamic_symbol_p
)
4425 /* xgettext:c-format */
4426 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4427 input_bfd
, h
->root
.root
.root
.string
);
4430 /* The regular PC-relative stuff measures from the start of
4431 the instruction rather than the end. */
4440 /* The regular PC-relative stuff measures from the start of
4441 the instruction rather than the end. */
4444 /* The source and destination gp must be the same. Note that
4445 the source will always have an assigned gp, since we forced
4446 one in check_relocs, but that the destination may not, as
4447 it might not have had any relocations at all. Also take
4448 care not to crash if H is an undefined symbol. */
4449 if (h
!= NULL
&& sec
!= NULL
4450 && alpha_elf_tdata (sec
->owner
)->gotobj
4451 && gotobj
!= alpha_elf_tdata (sec
->owner
)->gotobj
)
4454 /* xgettext:c-format */
4455 (_("%pB: change in gp: BRSGP %s"),
4456 input_bfd
, h
->root
.root
.root
.string
);
4460 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4462 other
= h
->root
.other
;
4464 other
= sym
->st_other
;
4465 switch (other
& STO_ALPHA_STD_GPLOAD
)
4467 case STO_ALPHA_NOPV
:
4469 case STO_ALPHA_STD_GPLOAD
:
4474 name
= h
->root
.root
.root
.string
;
4477 name
= (bfd_elf_string_from_elf_section
4478 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4480 name
= _("<unknown>");
4481 else if (name
[0] == 0)
4482 name
= bfd_section_name (sec
);
4485 /* xgettext:c-format */
4486 (_("%pB: !samegp reloc against symbol without .prologue: %s"),
4495 case R_ALPHA_REFLONG
:
4496 case R_ALPHA_REFQUAD
:
4497 case R_ALPHA_DTPREL64
:
4498 case R_ALPHA_TPREL64
:
4500 long dynindx
, dyntype
= r_type
;
4503 /* Careful here to remember RELATIVE relocations for global
4504 variables for symbolic shared objects. */
4506 if (dynamic_symbol_p
)
4508 BFD_ASSERT(h
->root
.dynindx
!= -1);
4509 dynindx
= h
->root
.dynindx
;
4511 addend
= 0, value
= 0;
4513 else if (r_type
== R_ALPHA_DTPREL64
)
4515 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4519 else if (r_type
== R_ALPHA_TPREL64
)
4521 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4522 if (!bfd_link_dll (info
))
4528 dynaddend
= value
- dtp_base
;
4530 else if (bfd_link_pic (info
)
4531 && r_symndx
!= STN_UNDEF
4532 && (input_section
->flags
& SEC_ALLOC
)
4534 && !(unresolved_reloc
4535 && (_bfd_elf_section_offset (output_bfd
, info
,
4540 if (r_type
== R_ALPHA_REFLONG
)
4543 /* xgettext:c-format */
4544 (_("%pB: unhandled dynamic relocation against %s"),
4546 h
->root
.root
.root
.string
);
4550 dyntype
= R_ALPHA_RELATIVE
;
4556 if (input_section
->flags
& SEC_ALLOC
)
4557 elf64_alpha_emit_dynrel (output_bfd
, info
, input_section
,
4558 srel
, rel
->r_offset
, dynindx
,
4559 dyntype
, dynaddend
);
4563 case R_ALPHA_SREL16
:
4564 case R_ALPHA_SREL32
:
4565 case R_ALPHA_SREL64
:
4566 if (dynamic_symbol_p
)
4569 /* xgettext:c-format */
4570 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4571 input_bfd
, h
->root
.root
.root
.string
);
4574 else if (bfd_link_pic (info
)
4578 /* xgettext:c-format */
4579 (_("%pB: pc-relative relocation against undefined weak symbol %s"),
4580 input_bfd
, h
->root
.root
.root
.string
);
4585 /* ??? .eh_frame references to discarded sections will be smashed
4586 to relocations against SHN_UNDEF. The .eh_frame format allows
4587 NULL to be encoded as 0 in any format, so this works here. */
4588 if (r_symndx
== STN_UNDEF
4589 || (unresolved_reloc
4590 && _bfd_elf_section_offset (output_bfd
, info
,
4592 rel
->r_offset
) == (bfd_vma
) -1))
4593 howto
= (elf64_alpha_howto_table
4594 + (r_type
- R_ALPHA_SREL32
+ R_ALPHA_REFLONG
));
4597 case R_ALPHA_TLSLDM
:
4598 /* Ignore the symbol for the relocation. The result is always
4599 the current module. */
4600 dynamic_symbol_p
= 0;
4604 if (!gotent
->reloc_done
)
4606 gotent
->reloc_done
= 1;
4608 /* Note that the module index for the main program is 1. */
4609 bfd_put_64 (output_bfd
,
4610 !bfd_link_pic (info
) && !dynamic_symbol_p
,
4611 sgot
->contents
+ gotent
->got_offset
);
4613 /* If the symbol has been forced local, output a
4614 DTPMOD64 reloc, otherwise it will be handled in
4615 finish_dynamic_symbol. */
4616 if (bfd_link_pic (info
) && !dynamic_symbol_p
)
4617 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4618 gotent
->got_offset
, 0,
4619 R_ALPHA_DTPMOD64
, 0);
4621 if (dynamic_symbol_p
|| r_type
== R_ALPHA_TLSLDM
)
4625 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4628 bfd_put_64 (output_bfd
, value
,
4629 sgot
->contents
+ gotent
->got_offset
+ 8);
4632 value
= (sgot
->output_section
->vma
4633 + sgot
->output_offset
4634 + gotent
->got_offset
);
4638 case R_ALPHA_DTPRELHI
:
4639 case R_ALPHA_DTPRELLO
:
4640 case R_ALPHA_DTPREL16
:
4641 if (dynamic_symbol_p
)
4644 /* xgettext:c-format */
4645 (_("%pB: dtp-relative relocation against dynamic symbol %s"),
4646 input_bfd
, h
->root
.root
.root
.string
);
4649 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4651 if (r_type
== R_ALPHA_DTPRELHI
)
4652 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4655 case R_ALPHA_TPRELHI
:
4656 case R_ALPHA_TPRELLO
:
4657 case R_ALPHA_TPREL16
:
4658 if (bfd_link_dll (info
))
4661 /* xgettext:c-format */
4662 (_("%pB: TLS local exec code cannot be linked into shared objects"),
4666 else if (dynamic_symbol_p
)
4669 /* xgettext:c-format */
4670 (_("%pB: tp-relative relocation against dynamic symbol %s"),
4671 input_bfd
, h
->root
.root
.root
.string
);
4674 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4676 if (r_type
== R_ALPHA_TPRELHI
)
4677 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4680 case R_ALPHA_GOTDTPREL
:
4681 case R_ALPHA_GOTTPREL
:
4682 BFD_ASSERT(sgot
!= NULL
);
4683 BFD_ASSERT(gp
!= 0);
4684 BFD_ASSERT(gotent
!= NULL
);
4685 BFD_ASSERT(gotent
->use_count
>= 1);
4687 if (!gotent
->reloc_done
)
4689 gotent
->reloc_done
= 1;
4691 if (dynamic_symbol_p
)
4695 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4696 if (r_type
== R_ALPHA_GOTDTPREL
)
4698 else if (bfd_link_executable (info
))
4702 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4703 gotent
->got_offset
, 0,
4709 bfd_put_64 (output_bfd
, value
,
4710 sgot
->contents
+ gotent
->got_offset
);
4713 value
= (sgot
->output_section
->vma
4714 + sgot
->output_offset
4715 + gotent
->got_offset
);
4721 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4722 contents
, rel
->r_offset
, value
, 0);
4731 case bfd_reloc_overflow
:
4735 /* Don't warn if the overflow is due to pc relative reloc
4736 against discarded section. Section optimization code should
4739 if (r_symndx
< symtab_hdr
->sh_info
4740 && sec
!= NULL
&& howto
->pc_relative
4741 && discarded_section (sec
))
4748 name
= (bfd_elf_string_from_elf_section
4749 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4753 name
= bfd_section_name (sec
);
4755 (*info
->callbacks
->reloc_overflow
)
4756 (info
, (h
? &h
->root
.root
: NULL
), name
, howto
->name
,
4757 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
4762 case bfd_reloc_outofrange
:
4770 /* Finish up dynamic symbol handling. We set the contents of various
4771 dynamic sections here. */
4774 elf64_alpha_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
4775 struct elf_link_hash_entry
*h
,
4776 Elf_Internal_Sym
*sym
)
4778 struct alpha_elf_link_hash_entry
*ah
= (struct alpha_elf_link_hash_entry
*)h
;
4782 /* Fill in the .plt entry for this symbol. */
4783 asection
*splt
, *sgot
, *srel
;
4784 Elf_Internal_Rela outrel
;
4786 bfd_vma got_addr
, plt_addr
;
4788 struct alpha_elf_got_entry
*gotent
;
4790 BFD_ASSERT (h
->dynindx
!= -1);
4792 splt
= elf_hash_table (info
)->splt
;
4793 BFD_ASSERT (splt
!= NULL
);
4794 srel
= elf_hash_table (info
)->srelplt
;
4795 BFD_ASSERT (srel
!= NULL
);
4797 for (gotent
= ah
->got_entries
; gotent
; gotent
= gotent
->next
)
4798 if (gotent
->reloc_type
== R_ALPHA_LITERAL
4799 && gotent
->use_count
> 0)
4804 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4805 BFD_ASSERT (sgot
!= NULL
);
4807 BFD_ASSERT (gotent
->got_offset
!= -1);
4808 BFD_ASSERT (gotent
->plt_offset
!= -1);
4810 got_addr
= (sgot
->output_section
->vma
4811 + sgot
->output_offset
4812 + gotent
->got_offset
);
4813 plt_addr
= (splt
->output_section
->vma
4814 + splt
->output_offset
4815 + gotent
->plt_offset
);
4817 plt_index
= (gotent
->plt_offset
-PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
4819 /* Fill in the entry in the procedure linkage table. */
4820 if (elf64_alpha_use_secureplt
)
4822 disp
= (PLT_HEADER_SIZE
- 4) - (gotent
->plt_offset
+ 4);
4823 insn
= INSN_AD (INSN_BR
, 31, disp
);
4824 bfd_put_32 (output_bfd
, insn
,
4825 splt
->contents
+ gotent
->plt_offset
);
4827 plt_index
= ((gotent
->plt_offset
- NEW_PLT_HEADER_SIZE
)
4828 / NEW_PLT_ENTRY_SIZE
);
4832 disp
= -(gotent
->plt_offset
+ 4);
4833 insn
= INSN_AD (INSN_BR
, 28, disp
);
4834 bfd_put_32 (output_bfd
, insn
,
4835 splt
->contents
+ gotent
->plt_offset
);
4836 bfd_put_32 (output_bfd
, INSN_UNOP
,
4837 splt
->contents
+ gotent
->plt_offset
+ 4);
4838 bfd_put_32 (output_bfd
, INSN_UNOP
,
4839 splt
->contents
+ gotent
->plt_offset
+ 8);
4841 plt_index
= ((gotent
->plt_offset
- OLD_PLT_HEADER_SIZE
)
4842 / OLD_PLT_ENTRY_SIZE
);
4845 /* Fill in the entry in the .rela.plt section. */
4846 outrel
.r_offset
= got_addr
;
4847 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
4848 outrel
.r_addend
= 0;
4850 loc
= srel
->contents
+ plt_index
* sizeof (Elf64_External_Rela
);
4851 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
4853 /* Fill in the entry in the .got. */
4854 bfd_put_64 (output_bfd
, plt_addr
,
4855 sgot
->contents
+ gotent
->got_offset
);
4858 else if (alpha_elf_dynamic_symbol_p (h
, info
))
4860 /* Fill in the dynamic relocations for this symbol's .got entries. */
4862 struct alpha_elf_got_entry
*gotent
;
4864 srel
= elf_hash_table (info
)->srelgot
;
4865 BFD_ASSERT (srel
!= NULL
);
4867 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4869 gotent
= gotent
->next
)
4874 if (gotent
->use_count
== 0)
4877 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4879 r_type
= gotent
->reloc_type
;
4882 case R_ALPHA_LITERAL
:
4883 r_type
= R_ALPHA_GLOB_DAT
;
4886 r_type
= R_ALPHA_DTPMOD64
;
4888 case R_ALPHA_GOTDTPREL
:
4889 r_type
= R_ALPHA_DTPREL64
;
4891 case R_ALPHA_GOTTPREL
:
4892 r_type
= R_ALPHA_TPREL64
;
4894 case R_ALPHA_TLSLDM
:
4899 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4900 gotent
->got_offset
, h
->dynindx
,
4901 r_type
, gotent
->addend
);
4903 if (gotent
->reloc_type
== R_ALPHA_TLSGD
)
4904 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4905 gotent
->got_offset
+ 8, h
->dynindx
,
4906 R_ALPHA_DTPREL64
, gotent
->addend
);
4910 /* Mark some specially defined symbols as absolute. */
4911 if (h
== elf_hash_table (info
)->hdynamic
4912 || h
== elf_hash_table (info
)->hgot
4913 || h
== elf_hash_table (info
)->hplt
)
4914 sym
->st_shndx
= SHN_ABS
;
4919 /* Finish up the dynamic sections. */
4922 elf64_alpha_finish_dynamic_sections (bfd
*output_bfd
,
4923 struct bfd_link_info
*info
)
4928 dynobj
= elf_hash_table (info
)->dynobj
;
4929 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4931 if (elf_hash_table (info
)->dynamic_sections_created
)
4933 asection
*splt
, *sgotplt
, *srelaplt
;
4934 Elf64_External_Dyn
*dyncon
, *dynconend
;
4935 bfd_vma plt_vma
, gotplt_vma
;
4937 splt
= elf_hash_table (info
)->splt
;
4938 srelaplt
= elf_hash_table (info
)->srelplt
;
4939 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4941 plt_vma
= splt
->output_section
->vma
+ splt
->output_offset
;
4944 if (elf64_alpha_use_secureplt
)
4946 sgotplt
= elf_hash_table (info
)->sgotplt
;
4947 BFD_ASSERT (sgotplt
!= NULL
);
4948 if (sgotplt
->size
> 0)
4949 gotplt_vma
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4952 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
4953 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4954 for (; dyncon
< dynconend
; dyncon
++)
4956 Elf_Internal_Dyn dyn
;
4958 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4964 = elf64_alpha_use_secureplt
? gotplt_vma
: plt_vma
;
4967 dyn
.d_un
.d_val
= srelaplt
? srelaplt
->size
: 0;
4970 dyn
.d_un
.d_ptr
= srelaplt
? (srelaplt
->output_section
->vma
4971 + srelaplt
->output_offset
) : 0;
4975 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4978 /* Initialize the plt header. */
4984 if (elf64_alpha_use_secureplt
)
4986 ofs
= gotplt_vma
- (plt_vma
+ PLT_HEADER_SIZE
);
4988 insn
= INSN_ABC (INSN_SUBQ
, 27, 28, 25);
4989 bfd_put_32 (output_bfd
, insn
, splt
->contents
);
4991 insn
= INSN_ABO (INSN_LDAH
, 28, 28, (ofs
+ 0x8000) >> 16);
4992 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 4);
4994 insn
= INSN_ABC (INSN_S4SUBQ
, 25, 25, 25);
4995 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 8);
4997 insn
= INSN_ABO (INSN_LDA
, 28, 28, ofs
);
4998 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 12);
5000 insn
= INSN_ABO (INSN_LDQ
, 27, 28, 0);
5001 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 16);
5003 insn
= INSN_ABC (INSN_ADDQ
, 25, 25, 25);
5004 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 20);
5006 insn
= INSN_ABO (INSN_LDQ
, 28, 28, 8);
5007 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 24);
5009 insn
= INSN_AB (INSN_JMP
, 31, 27);
5010 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 28);
5012 insn
= INSN_AD (INSN_BR
, 28, -PLT_HEADER_SIZE
);
5013 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 32);
5017 insn
= INSN_AD (INSN_BR
, 27, 0); /* br $27, .+4 */
5018 bfd_put_32 (output_bfd
, insn
, splt
->contents
);
5020 insn
= INSN_ABO (INSN_LDQ
, 27, 27, 12);
5021 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 4);
5024 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 8);
5026 insn
= INSN_AB (INSN_JMP
, 27, 27);
5027 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 12);
5029 /* The next two words will be filled in by ld.so. */
5030 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 16);
5031 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 24);
5034 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 0;
5041 /* We need to use a special link routine to handle the .mdebug section.
5042 We need to merge all instances of these sections together, not write
5043 them all out sequentially. */
5046 elf64_alpha_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
5049 struct bfd_link_order
*p
;
5050 asection
*mdebug_sec
;
5051 struct ecoff_debug_info debug
;
5052 const struct ecoff_debug_swap
*swap
5053 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
5054 HDRR
*symhdr
= &debug
.symbolic_header
;
5055 void * mdebug_handle
= NULL
;
5056 struct alpha_elf_link_hash_table
* htab
;
5058 htab
= alpha_elf_hash_table (info
);
5062 /* Go through the sections and collect the mdebug information. */
5064 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5066 if (strcmp (o
->name
, ".mdebug") == 0)
5068 struct extsym_info einfo
;
5070 /* We have found the .mdebug section in the output file.
5071 Look through all the link_orders comprising it and merge
5072 the information together. */
5073 symhdr
->magic
= swap
->sym_magic
;
5074 /* FIXME: What should the version stamp be? */
5076 symhdr
->ilineMax
= 0;
5080 symhdr
->isymMax
= 0;
5081 symhdr
->ioptMax
= 0;
5082 symhdr
->iauxMax
= 0;
5084 symhdr
->issExtMax
= 0;
5087 symhdr
->iextMax
= 0;
5089 /* We accumulate the debugging information itself in the
5090 debug_info structure. */
5092 debug
.external_dnr
= NULL
;
5093 debug
.external_pdr
= NULL
;
5094 debug
.external_sym
= NULL
;
5095 debug
.external_opt
= NULL
;
5096 debug
.external_aux
= NULL
;
5098 debug
.ssext
= debug
.ssext_end
= NULL
;
5099 debug
.external_fdr
= NULL
;
5100 debug
.external_rfd
= NULL
;
5101 debug
.external_ext
= debug
.external_ext_end
= NULL
;
5103 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
5104 if (mdebug_handle
== NULL
)
5113 static const char * const name
[] =
5115 ".text", ".init", ".fini", ".data",
5116 ".rodata", ".sdata", ".sbss", ".bss"
5118 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
5119 scRData
, scSData
, scSBss
, scBss
};
5122 esym
.cobol_main
= 0;
5126 esym
.asym
.iss
= issNil
;
5127 esym
.asym
.st
= stLocal
;
5128 esym
.asym
.reserved
= 0;
5129 esym
.asym
.index
= indexNil
;
5130 for (i
= 0; i
< 8; i
++)
5132 esym
.asym
.sc
= sc
[i
];
5133 s
= bfd_get_section_by_name (abfd
, name
[i
]);
5136 esym
.asym
.value
= s
->vma
;
5137 last
= s
->vma
+ s
->size
;
5140 esym
.asym
.value
= last
;
5142 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
5148 for (p
= o
->map_head
.link_order
;
5149 p
!= (struct bfd_link_order
*) NULL
;
5152 asection
*input_section
;
5154 const struct ecoff_debug_swap
*input_swap
;
5155 struct ecoff_debug_info input_debug
;
5159 if (p
->type
!= bfd_indirect_link_order
)
5161 if (p
->type
== bfd_data_link_order
)
5166 input_section
= p
->u
.indirect
.section
;
5167 input_bfd
= input_section
->owner
;
5169 if (! is_alpha_elf (input_bfd
))
5170 /* I don't know what a non ALPHA ELF bfd would be
5171 doing with a .mdebug section, but I don't really
5172 want to deal with it. */
5175 input_swap
= (get_elf_backend_data (input_bfd
)
5176 ->elf_backend_ecoff_debug_swap
);
5178 BFD_ASSERT (p
->size
== input_section
->size
);
5180 /* The ECOFF linking code expects that we have already
5181 read in the debugging information and set up an
5182 ecoff_debug_info structure, so we do that now. */
5183 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
5187 if (! (bfd_ecoff_debug_accumulate
5188 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
5189 &input_debug
, input_swap
, info
)))
5192 /* Loop through the external symbols. For each one with
5193 interesting information, try to find the symbol in
5194 the linker global hash table and save the information
5195 for the output external symbols. */
5196 eraw_src
= (char *) input_debug
.external_ext
;
5197 eraw_end
= (eraw_src
5198 + (input_debug
.symbolic_header
.iextMax
5199 * input_swap
->external_ext_size
));
5201 eraw_src
< eraw_end
;
5202 eraw_src
+= input_swap
->external_ext_size
)
5206 struct alpha_elf_link_hash_entry
*h
;
5208 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
5209 if (ext
.asym
.sc
== scNil
5210 || ext
.asym
.sc
== scUndefined
5211 || ext
.asym
.sc
== scSUndefined
)
5214 name
= input_debug
.ssext
+ ext
.asym
.iss
;
5215 h
= alpha_elf_link_hash_lookup (htab
, name
, false, false, true);
5216 if (h
== NULL
|| h
->esym
.ifd
!= -2)
5222 < input_debug
.symbolic_header
.ifdMax
);
5223 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
5229 /* Free up the information we just read. */
5230 free (input_debug
.line
);
5231 free (input_debug
.external_dnr
);
5232 free (input_debug
.external_pdr
);
5233 free (input_debug
.external_sym
);
5234 free (input_debug
.external_opt
);
5235 free (input_debug
.external_aux
);
5236 free (input_debug
.ss
);
5237 free (input_debug
.ssext
);
5238 free (input_debug
.external_fdr
);
5239 free (input_debug
.external_rfd
);
5240 free (input_debug
.external_ext
);
5242 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5243 elf_link_input_bfd ignores this section. */
5244 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
5247 /* Build the external symbol information. */
5250 einfo
.debug
= &debug
;
5252 einfo
.failed
= false;
5253 elf_link_hash_traverse (elf_hash_table (info
),
5254 elf64_alpha_output_extsym
,
5259 /* Set the size of the .mdebug section. */
5260 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
5262 /* Skip this section later on (I don't think this currently
5263 matters, but someday it might). */
5264 o
->map_head
.link_order
= (struct bfd_link_order
*) NULL
;
5270 /* Invoke the regular ELF backend linker to do all the work. */
5271 if (! bfd_elf_final_link (abfd
, info
))
5274 /* Now write out the computed sections. */
5276 /* The .got subsections... */
5278 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
5279 for (i
= htab
->got_list
;
5281 i
= alpha_elf_tdata(i
)->got_link_next
)
5285 /* elf_bfd_final_link already did everything in dynobj. */
5289 sgot
= alpha_elf_tdata(i
)->got
;
5290 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
5292 (file_ptr
) sgot
->output_offset
,
5298 if (mdebug_sec
!= (asection
*) NULL
)
5300 BFD_ASSERT (abfd
->output_has_begun
);
5301 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5303 mdebug_sec
->filepos
))
5306 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5312 static enum elf_reloc_type_class
5313 elf64_alpha_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5314 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5315 const Elf_Internal_Rela
*rela
)
5317 switch ((int) ELF64_R_TYPE (rela
->r_info
))
5319 case R_ALPHA_RELATIVE
:
5320 return reloc_class_relative
;
5321 case R_ALPHA_JMP_SLOT
:
5322 return reloc_class_plt
;
5324 return reloc_class_copy
;
5326 return reloc_class_normal
;
5330 static const struct bfd_elf_special_section elf64_alpha_special_sections
[] =
5332 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5333 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5334 { NULL
, 0, 0, 0, 0 }
5337 /* ECOFF swapping routines. These are used when dealing with the
5338 .mdebug section, which is in the ECOFF debugging format. Copied
5339 from elf32-mips.c. */
5340 static const struct ecoff_debug_swap
5341 elf64_alpha_ecoff_debug_swap
=
5343 /* Symbol table magic number. */
5345 /* Alignment of debugging information. E.g., 4. */
5347 /* Sizes of external symbolic information. */
5348 sizeof (struct hdr_ext
),
5349 sizeof (struct dnr_ext
),
5350 sizeof (struct pdr_ext
),
5351 sizeof (struct sym_ext
),
5352 sizeof (struct opt_ext
),
5353 sizeof (struct fdr_ext
),
5354 sizeof (struct rfd_ext
),
5355 sizeof (struct ext_ext
),
5356 /* Functions to swap in external symbolic data. */
5365 _bfd_ecoff_swap_tir_in
,
5366 _bfd_ecoff_swap_rndx_in
,
5367 /* Functions to swap out external symbolic data. */
5376 _bfd_ecoff_swap_tir_out
,
5377 _bfd_ecoff_swap_rndx_out
,
5378 /* Function to read in symbolic data. */
5379 elf64_alpha_read_ecoff_info
5382 /* Use a non-standard hash bucket size of 8. */
5384 static const struct elf_size_info alpha_elf_size_info
=
5386 sizeof (Elf64_External_Ehdr
),
5387 sizeof (Elf64_External_Phdr
),
5388 sizeof (Elf64_External_Shdr
),
5389 sizeof (Elf64_External_Rel
),
5390 sizeof (Elf64_External_Rela
),
5391 sizeof (Elf64_External_Sym
),
5392 sizeof (Elf64_External_Dyn
),
5393 sizeof (Elf_External_Note
),
5397 ELFCLASS64
, EV_CURRENT
,
5398 bfd_elf64_write_out_phdrs
,
5399 bfd_elf64_write_shdrs_and_ehdr
,
5400 bfd_elf64_checksum_contents
,
5401 bfd_elf64_write_relocs
,
5402 bfd_elf64_swap_symbol_in
,
5403 bfd_elf64_swap_symbol_out
,
5404 bfd_elf64_slurp_reloc_table
,
5405 bfd_elf64_slurp_symbol_table
,
5406 bfd_elf64_swap_dyn_in
,
5407 bfd_elf64_swap_dyn_out
,
5408 bfd_elf64_swap_reloc_in
,
5409 bfd_elf64_swap_reloc_out
,
5410 bfd_elf64_swap_reloca_in
,
5411 bfd_elf64_swap_reloca_out
5414 #define TARGET_LITTLE_SYM alpha_elf64_vec
5415 #define TARGET_LITTLE_NAME "elf64-alpha"
5416 #define ELF_ARCH bfd_arch_alpha
5417 #define ELF_TARGET_ID ALPHA_ELF_DATA
5418 #define ELF_MACHINE_CODE EM_ALPHA
5419 #define ELF_MAXPAGESIZE 0x10000
5420 #define ELF_COMMONPAGESIZE 0x2000
5422 #define bfd_elf64_bfd_link_hash_table_create \
5423 elf64_alpha_bfd_link_hash_table_create
5425 #define bfd_elf64_bfd_reloc_type_lookup \
5426 elf64_alpha_bfd_reloc_type_lookup
5427 #define bfd_elf64_bfd_reloc_name_lookup \
5428 elf64_alpha_bfd_reloc_name_lookup
5429 #define elf_info_to_howto \
5430 elf64_alpha_info_to_howto
5432 #define bfd_elf64_mkobject \
5433 elf64_alpha_mkobject
5434 #define elf_backend_object_p \
5435 elf64_alpha_object_p
5437 #define elf_backend_section_from_shdr \
5438 elf64_alpha_section_from_shdr
5439 #define elf_backend_section_flags \
5440 elf64_alpha_section_flags
5441 #define elf_backend_fake_sections \
5442 elf64_alpha_fake_sections
5444 #define bfd_elf64_bfd_is_local_label_name \
5445 elf64_alpha_is_local_label_name
5446 #define bfd_elf64_find_nearest_line \
5447 elf64_alpha_find_nearest_line
5448 #define bfd_elf64_bfd_relax_section \
5449 elf64_alpha_relax_section
5451 #define elf_backend_add_symbol_hook \
5452 elf64_alpha_add_symbol_hook
5453 #define elf_backend_relocs_compatible \
5454 _bfd_elf_relocs_compatible
5455 #define elf_backend_sort_relocs_p \
5456 elf64_alpha_sort_relocs_p
5457 #define elf_backend_check_relocs \
5458 elf64_alpha_check_relocs
5459 #define elf_backend_create_dynamic_sections \
5460 elf64_alpha_create_dynamic_sections
5461 #define elf_backend_adjust_dynamic_symbol \
5462 elf64_alpha_adjust_dynamic_symbol
5463 #define elf_backend_merge_symbol_attribute \
5464 elf64_alpha_merge_symbol_attribute
5465 #define elf_backend_copy_indirect_symbol \
5466 elf64_alpha_copy_indirect_symbol
5467 #define elf_backend_always_size_sections \
5468 elf64_alpha_always_size_sections
5469 #define elf_backend_size_dynamic_sections \
5470 elf64_alpha_size_dynamic_sections
5471 #define elf_backend_omit_section_dynsym \
5472 _bfd_elf_omit_section_dynsym_all
5473 #define elf_backend_relocate_section \
5474 elf64_alpha_relocate_section
5475 #define elf_backend_finish_dynamic_symbol \
5476 elf64_alpha_finish_dynamic_symbol
5477 #define elf_backend_finish_dynamic_sections \
5478 elf64_alpha_finish_dynamic_sections
5479 #define bfd_elf64_bfd_final_link \
5480 elf64_alpha_final_link
5481 #define elf_backend_reloc_type_class \
5482 elf64_alpha_reloc_type_class
5484 #define elf_backend_can_gc_sections 1
5485 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5487 #define elf_backend_ecoff_debug_swap \
5488 &elf64_alpha_ecoff_debug_swap
5490 #define elf_backend_size_info \
5493 #define elf_backend_special_sections \
5494 elf64_alpha_special_sections
5496 #define elf_backend_strip_zero_sized_dynamic_sections \
5497 _bfd_elf_strip_zero_sized_dynamic_sections
5499 /* A few constants that determine how the .plt section is set up. */
5500 #define elf_backend_want_got_plt 0
5501 #define elf_backend_plt_readonly 0
5502 #define elf_backend_want_plt_sym 1
5503 #define elf_backend_got_header_size 0
5504 #define elf_backend_dtrel_excludes_plt 1
5506 #include "elf64-target.h"
5508 /* FreeBSD support. */
5510 #undef TARGET_LITTLE_SYM
5511 #define TARGET_LITTLE_SYM alpha_elf64_fbsd_vec
5512 #undef TARGET_LITTLE_NAME
5513 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5515 #define ELF_OSABI ELFOSABI_FREEBSD
5517 /* The kernel recognizes executables as valid only if they carry a
5518 "FreeBSD" label in the ELF header. So we put this label on all
5519 executables and (for simplicity) also all other object files. */
5522 elf64_alpha_fbsd_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
5524 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
5526 if (!_bfd_elf_init_file_header (abfd
, info
))
5529 i_ehdrp
= elf_elfheader (abfd
);
5531 /* Put an ABI label supported by FreeBSD >= 4.1. */
5532 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
5533 #ifdef OLD_FREEBSD_ABI_LABEL
5534 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5535 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5540 #undef elf_backend_init_file_header
5541 #define elf_backend_init_file_header \
5542 elf64_alpha_fbsd_init_file_header
5545 #define elf64_bed elf64_alpha_fbsd_bed
5547 #include "elf64-target.h"