1 /* Alpha specific support for 64-bit ELF
2 Copyright (C) 1996-2020 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 | (A << 21))
77 #define INSN_AB(I,A,B) (I | (A << 21) | (B << 16))
78 #define INSN_ABC(I,A,B,C) (I | (A << 21) | (B << 16) | C)
79 #define INSN_ABO(I,A,B,O) (I | (A << 21) | (B << 16) | ((O) & 0xffff))
80 #define INSN_AD(I,A,D) (I | (A << 21) | (((D) >> 2) & 0x1fffff))
84 /* Set by ld emulation. Putting this into the link_info or hash structure
85 is simply working too hard. */
87 bfd_boolean elf64_alpha_use_secureplt
= TRUE
;
89 bfd_boolean 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 /* What kind of relocation? */
150 /* Is this against read-only section? */
151 unsigned int reltext
: 1;
153 /* How many did we find? */
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 (bfd_boolean (*) (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 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
220 == ALPHA_ELF_DATA ? ((struct alpha_elf_link_hash_table *) ((p)->hash)) : NULL)
222 /* Get the object's symbols as our own entry type. */
224 #define alpha_elf_sym_hashes(abfd) \
225 ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
227 /* Should we do dynamic things to this symbol? This differs from the
228 generic version in that we never need to consider function pointer
229 equality wrt PLT entries -- we don't create a PLT entry if a symbol's
230 address is ever taken. */
232 static inline bfd_boolean
233 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
234 struct bfd_link_info
*info
)
236 return _bfd_elf_dynamic_symbol_p (h
, info
, 0);
239 /* Create an entry in a Alpha ELF linker hash table. */
241 static struct bfd_hash_entry
*
242 elf64_alpha_link_hash_newfunc (struct bfd_hash_entry
*entry
,
243 struct bfd_hash_table
*table
,
246 struct alpha_elf_link_hash_entry
*ret
=
247 (struct alpha_elf_link_hash_entry
*) entry
;
249 /* Allocate the structure if it has not already been allocated by a
251 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
252 ret
= ((struct alpha_elf_link_hash_entry
*)
253 bfd_hash_allocate (table
,
254 sizeof (struct alpha_elf_link_hash_entry
)));
255 if (ret
== (struct alpha_elf_link_hash_entry
*) NULL
)
256 return (struct bfd_hash_entry
*) ret
;
258 /* Call the allocation method of the superclass. */
259 ret
= ((struct alpha_elf_link_hash_entry
*)
260 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
262 if (ret
!= (struct alpha_elf_link_hash_entry
*) NULL
)
264 /* Set local fields. */
265 memset (&ret
->esym
, 0, sizeof (EXTR
));
266 /* We use -2 as a marker to indicate that the information has
267 not been set. -1 means there is no associated ifd. */
270 ret
->got_entries
= NULL
;
271 ret
->reloc_entries
= NULL
;
274 return (struct bfd_hash_entry
*) ret
;
277 /* Create a Alpha ELF linker hash table. */
279 static struct bfd_link_hash_table
*
280 elf64_alpha_bfd_link_hash_table_create (bfd
*abfd
)
282 struct alpha_elf_link_hash_table
*ret
;
283 size_t amt
= sizeof (struct alpha_elf_link_hash_table
);
285 ret
= (struct alpha_elf_link_hash_table
*) bfd_zmalloc (amt
);
286 if (ret
== (struct alpha_elf_link_hash_table
*) NULL
)
289 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
290 elf64_alpha_link_hash_newfunc
,
291 sizeof (struct alpha_elf_link_hash_entry
),
298 return &ret
->root
.root
;
301 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
302 routine in order to handle the ECOFF debugging information. */
304 struct alpha_elf_find_line
306 struct ecoff_debug_info d
;
307 struct ecoff_find_line i
;
310 /* We have some private fields hanging off of the elf_tdata structure. */
312 struct alpha_elf_obj_tdata
314 struct elf_obj_tdata root
;
316 /* For every input file, these are the got entries for that object's
318 struct alpha_elf_got_entry
** local_got_entries
;
320 /* For every input file, this is the object that owns the got that
321 this input file uses. */
324 /* For every got, this is a linked list through the objects using this got */
325 bfd
*in_got_link_next
;
327 /* For every got, this is a link to the next got subsegment. */
330 /* For every got, this is the section. */
333 /* For every got, this is it's total number of words. */
336 /* For every got, this is the sum of the number of words required
337 to hold all of the member object's local got. */
340 /* Used by elf64_alpha_find_nearest_line entry point. */
341 struct alpha_elf_find_line
*find_line_info
;
345 #define alpha_elf_tdata(abfd) \
346 ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
348 #define is_alpha_elf(bfd) \
349 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
350 && elf_tdata (bfd) != NULL \
351 && elf_object_id (bfd) == ALPHA_ELF_DATA)
354 elf64_alpha_mkobject (bfd
*abfd
)
356 return bfd_elf_allocate_object (abfd
, sizeof (struct alpha_elf_obj_tdata
),
361 elf64_alpha_object_p (bfd
*abfd
)
363 /* Set the right machine number for an Alpha ELF file. */
364 return bfd_default_set_arch_mach (abfd
, bfd_arch_alpha
, 0);
367 /* A relocation function which doesn't do anything. */
369 static bfd_reloc_status_type
370 elf64_alpha_reloc_nil (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc
,
371 asymbol
*sym ATTRIBUTE_UNUSED
,
372 void * data ATTRIBUTE_UNUSED
, asection
*sec
,
373 bfd
*output_bfd
, char **error_message ATTRIBUTE_UNUSED
)
376 reloc
->address
+= sec
->output_offset
;
380 /* A relocation function used for an unsupported reloc. */
382 static bfd_reloc_status_type
383 elf64_alpha_reloc_bad (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc
,
384 asymbol
*sym ATTRIBUTE_UNUSED
,
385 void * data ATTRIBUTE_UNUSED
, asection
*sec
,
386 bfd
*output_bfd
, char **error_message ATTRIBUTE_UNUSED
)
389 reloc
->address
+= sec
->output_offset
;
390 return bfd_reloc_notsupported
;
393 /* Do the work of the GPDISP relocation. */
395 static bfd_reloc_status_type
396 elf64_alpha_do_reloc_gpdisp (bfd
*abfd
, bfd_vma gpdisp
, bfd_byte
*p_ldah
,
399 bfd_reloc_status_type ret
= bfd_reloc_ok
;
401 unsigned long i_ldah
, i_lda
;
403 i_ldah
= bfd_get_32 (abfd
, p_ldah
);
404 i_lda
= bfd_get_32 (abfd
, p_lda
);
406 /* Complain if the instructions are not correct. */
407 if (((i_ldah
>> 26) & 0x3f) != 0x09
408 || ((i_lda
>> 26) & 0x3f) != 0x08)
409 ret
= bfd_reloc_dangerous
;
411 /* Extract the user-supplied offset, mirroring the sign extensions
412 that the instructions perform. */
413 addend
= ((i_ldah
& 0xffff) << 16) | (i_lda
& 0xffff);
414 addend
= (addend
^ 0x80008000) - 0x80008000;
418 if ((bfd_signed_vma
) gpdisp
< -(bfd_signed_vma
) 0x80000000
419 || (bfd_signed_vma
) gpdisp
>= (bfd_signed_vma
) 0x7fff8000)
420 ret
= bfd_reloc_overflow
;
422 /* compensate for the sign extension again. */
423 i_ldah
= ((i_ldah
& 0xffff0000)
424 | (((gpdisp
>> 16) + ((gpdisp
>> 15) & 1)) & 0xffff));
425 i_lda
= (i_lda
& 0xffff0000) | (gpdisp
& 0xffff);
427 bfd_put_32 (abfd
, (bfd_vma
) i_ldah
, p_ldah
);
428 bfd_put_32 (abfd
, (bfd_vma
) i_lda
, p_lda
);
433 /* The special function for the GPDISP reloc. */
435 static bfd_reloc_status_type
436 elf64_alpha_reloc_gpdisp (bfd
*abfd
, arelent
*reloc_entry
,
437 asymbol
*sym ATTRIBUTE_UNUSED
, void * data
,
438 asection
*input_section
, bfd
*output_bfd
,
441 bfd_reloc_status_type ret
;
442 bfd_vma gp
, relocation
;
443 bfd_vma high_address
;
444 bfd_byte
*p_ldah
, *p_lda
;
446 /* Don't do anything if we're not doing a final link. */
449 reloc_entry
->address
+= input_section
->output_offset
;
453 high_address
= bfd_get_section_limit (abfd
, input_section
);
454 if (reloc_entry
->address
> high_address
455 || reloc_entry
->address
+ reloc_entry
->addend
> high_address
)
456 return bfd_reloc_outofrange
;
458 /* The gp used in the portion of the output object to which this
459 input object belongs is cached on the input bfd. */
460 gp
= _bfd_get_gp_value (abfd
);
462 relocation
= (input_section
->output_section
->vma
463 + input_section
->output_offset
464 + reloc_entry
->address
);
466 p_ldah
= (bfd_byte
*) data
+ reloc_entry
->address
;
467 p_lda
= p_ldah
+ reloc_entry
->addend
;
469 ret
= elf64_alpha_do_reloc_gpdisp (abfd
, gp
- relocation
, p_ldah
, p_lda
);
471 /* Complain if the instructions are not correct. */
472 if (ret
== bfd_reloc_dangerous
)
473 *err_msg
= _("GPDISP relocation did not find ldah and lda instructions");
478 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
479 from smaller values. Start with zero, widen, *then* decrement. */
480 #define MINUS_ONE (((bfd_vma)0) - 1)
483 #define SKIP_HOWTO(N) \
484 HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
486 static reloc_howto_type elf64_alpha_howto_table
[] =
488 HOWTO (R_ALPHA_NONE
, /* type */
490 3, /* size (0 = byte, 1 = short, 2 = long) */
492 TRUE
, /* pc_relative */
494 complain_overflow_dont
, /* complain_on_overflow */
495 elf64_alpha_reloc_nil
, /* special_function */
497 FALSE
, /* partial_inplace */
500 TRUE
), /* pcrel_offset */
502 /* A 32 bit reference to a symbol. */
503 HOWTO (R_ALPHA_REFLONG
, /* type */
505 2, /* size (0 = byte, 1 = short, 2 = long) */
507 FALSE
, /* pc_relative */
509 complain_overflow_bitfield
, /* complain_on_overflow */
510 bfd_elf_generic_reloc
, /* special_function */
511 "REFLONG", /* name */
512 FALSE
, /* partial_inplace */
513 0xffffffff, /* src_mask */
514 0xffffffff, /* dst_mask */
515 FALSE
), /* pcrel_offset */
517 /* A 64 bit reference to a symbol. */
518 HOWTO (R_ALPHA_REFQUAD
, /* type */
520 4, /* size (0 = byte, 1 = short, 2 = long) */
522 FALSE
, /* pc_relative */
524 complain_overflow_bitfield
, /* complain_on_overflow */
525 bfd_elf_generic_reloc
, /* special_function */
526 "REFQUAD", /* name */
527 FALSE
, /* partial_inplace */
528 MINUS_ONE
, /* src_mask */
529 MINUS_ONE
, /* dst_mask */
530 FALSE
), /* pcrel_offset */
532 /* A 32 bit GP relative offset. This is just like REFLONG except
533 that when the value is used the value of the gp register will be
535 HOWTO (R_ALPHA_GPREL32
, /* type */
537 2, /* size (0 = byte, 1 = short, 2 = long) */
539 FALSE
, /* pc_relative */
541 complain_overflow_bitfield
, /* complain_on_overflow */
542 bfd_elf_generic_reloc
, /* special_function */
543 "GPREL32", /* name */
544 FALSE
, /* partial_inplace */
545 0xffffffff, /* src_mask */
546 0xffffffff, /* dst_mask */
547 FALSE
), /* pcrel_offset */
549 /* Used for an instruction that refers to memory off the GP register. */
550 HOWTO (R_ALPHA_LITERAL
, /* type */
552 1, /* size (0 = byte, 1 = short, 2 = long) */
554 FALSE
, /* pc_relative */
556 complain_overflow_signed
, /* complain_on_overflow */
557 bfd_elf_generic_reloc
, /* special_function */
558 "ELF_LITERAL", /* name */
559 FALSE
, /* partial_inplace */
560 0xffff, /* src_mask */
561 0xffff, /* dst_mask */
562 FALSE
), /* pcrel_offset */
564 /* This reloc only appears immediately following an ELF_LITERAL reloc.
565 It identifies a use of the literal. The symbol index is special:
566 1 means the literal address is in the base register of a memory
567 format instruction; 2 means the literal address is in the byte
568 offset register of a byte-manipulation instruction; 3 means the
569 literal address is in the target register of a jsr instruction.
570 This does not actually do any relocation. */
571 HOWTO (R_ALPHA_LITUSE
, /* type */
573 1, /* size (0 = byte, 1 = short, 2 = long) */
575 FALSE
, /* pc_relative */
577 complain_overflow_dont
, /* complain_on_overflow */
578 elf64_alpha_reloc_nil
, /* special_function */
580 FALSE
, /* partial_inplace */
583 FALSE
), /* pcrel_offset */
585 /* Load the gp register. This is always used for a ldah instruction
586 which loads the upper 16 bits of the gp register. The symbol
587 index of the GPDISP instruction is an offset in bytes to the lda
588 instruction that loads the lower 16 bits. The value to use for
589 the relocation is the difference between the GP value and the
590 current location; the load will always be done against a register
591 holding the current address.
593 NOTE: Unlike ECOFF, partial in-place relocation is not done. If
594 any offset is present in the instructions, it is an offset from
595 the register to the ldah instruction. This lets us avoid any
596 stupid hackery like inventing a gp value to do partial relocation
597 against. Also unlike ECOFF, we do the whole relocation off of
598 the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair. An odd,
599 space consuming bit, that, since all the information was present
600 in the GPDISP_HI16 reloc. */
601 HOWTO (R_ALPHA_GPDISP
, /* type */
603 2, /* size (0 = byte, 1 = short, 2 = long) */
605 FALSE
, /* pc_relative */
607 complain_overflow_dont
, /* complain_on_overflow */
608 elf64_alpha_reloc_gpdisp
, /* special_function */
610 FALSE
, /* partial_inplace */
611 0xffff, /* src_mask */
612 0xffff, /* dst_mask */
613 TRUE
), /* pcrel_offset */
615 /* A 21 bit branch. */
616 HOWTO (R_ALPHA_BRADDR
, /* type */
618 2, /* size (0 = byte, 1 = short, 2 = long) */
620 TRUE
, /* pc_relative */
622 complain_overflow_signed
, /* complain_on_overflow */
623 bfd_elf_generic_reloc
, /* special_function */
625 FALSE
, /* partial_inplace */
626 0x1fffff, /* src_mask */
627 0x1fffff, /* dst_mask */
628 TRUE
), /* pcrel_offset */
630 /* A hint for a jump to a register. */
631 HOWTO (R_ALPHA_HINT
, /* type */
633 1, /* size (0 = byte, 1 = short, 2 = long) */
635 TRUE
, /* pc_relative */
637 complain_overflow_dont
, /* complain_on_overflow */
638 bfd_elf_generic_reloc
, /* special_function */
640 FALSE
, /* partial_inplace */
641 0x3fff, /* src_mask */
642 0x3fff, /* dst_mask */
643 TRUE
), /* pcrel_offset */
645 /* 16 bit PC relative offset. */
646 HOWTO (R_ALPHA_SREL16
, /* type */
648 1, /* size (0 = byte, 1 = short, 2 = long) */
650 TRUE
, /* pc_relative */
652 complain_overflow_signed
, /* complain_on_overflow */
653 bfd_elf_generic_reloc
, /* special_function */
655 FALSE
, /* partial_inplace */
656 0xffff, /* src_mask */
657 0xffff, /* dst_mask */
658 TRUE
), /* pcrel_offset */
660 /* 32 bit PC relative offset. */
661 HOWTO (R_ALPHA_SREL32
, /* type */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
665 TRUE
, /* pc_relative */
667 complain_overflow_signed
, /* complain_on_overflow */
668 bfd_elf_generic_reloc
, /* special_function */
670 FALSE
, /* partial_inplace */
671 0xffffffff, /* src_mask */
672 0xffffffff, /* dst_mask */
673 TRUE
), /* pcrel_offset */
675 /* A 64 bit PC relative offset. */
676 HOWTO (R_ALPHA_SREL64
, /* type */
678 4, /* size (0 = byte, 1 = short, 2 = long) */
680 TRUE
, /* pc_relative */
682 complain_overflow_signed
, /* complain_on_overflow */
683 bfd_elf_generic_reloc
, /* special_function */
685 FALSE
, /* partial_inplace */
686 MINUS_ONE
, /* src_mask */
687 MINUS_ONE
, /* dst_mask */
688 TRUE
), /* pcrel_offset */
690 /* Skip 12 - 16; deprecated ECOFF relocs. */
697 /* The high 16 bits of the displacement from GP to the target. */
698 HOWTO (R_ALPHA_GPRELHIGH
,
700 1, /* size (0 = byte, 1 = short, 2 = long) */
702 FALSE
, /* pc_relative */
704 complain_overflow_signed
, /* complain_on_overflow */
705 bfd_elf_generic_reloc
, /* special_function */
706 "GPRELHIGH", /* name */
707 FALSE
, /* partial_inplace */
708 0xffff, /* src_mask */
709 0xffff, /* dst_mask */
710 FALSE
), /* pcrel_offset */
712 /* The low 16 bits of the displacement from GP to the target. */
713 HOWTO (R_ALPHA_GPRELLOW
,
715 1, /* size (0 = byte, 1 = short, 2 = long) */
717 FALSE
, /* pc_relative */
719 complain_overflow_dont
, /* complain_on_overflow */
720 bfd_elf_generic_reloc
, /* special_function */
721 "GPRELLOW", /* name */
722 FALSE
, /* partial_inplace */
723 0xffff, /* src_mask */
724 0xffff, /* dst_mask */
725 FALSE
), /* pcrel_offset */
727 /* A 16-bit displacement from the GP to the target. */
728 HOWTO (R_ALPHA_GPREL16
,
730 1, /* size (0 = byte, 1 = short, 2 = long) */
732 FALSE
, /* pc_relative */
734 complain_overflow_signed
, /* complain_on_overflow */
735 bfd_elf_generic_reloc
, /* special_function */
736 "GPREL16", /* name */
737 FALSE
, /* partial_inplace */
738 0xffff, /* src_mask */
739 0xffff, /* dst_mask */
740 FALSE
), /* pcrel_offset */
742 /* Skip 20 - 23; deprecated ECOFF relocs. */
748 /* Misc ELF relocations. */
750 /* A dynamic relocation to copy the target into our .dynbss section. */
751 /* Not generated, as all Alpha objects use PIC, so it is not needed. It
752 is present because every other ELF has one, but should not be used
753 because .dynbss is an ugly thing. */
760 complain_overflow_dont
,
761 bfd_elf_generic_reloc
,
768 /* A dynamic relocation for a .got entry. */
769 HOWTO (R_ALPHA_GLOB_DAT
,
775 complain_overflow_dont
,
776 bfd_elf_generic_reloc
,
783 /* A dynamic relocation for a .plt entry. */
784 HOWTO (R_ALPHA_JMP_SLOT
,
790 complain_overflow_dont
,
791 bfd_elf_generic_reloc
,
798 /* A dynamic relocation to add the base of the DSO to a 64-bit field. */
799 HOWTO (R_ALPHA_RELATIVE
,
805 complain_overflow_dont
,
806 bfd_elf_generic_reloc
,
813 /* A 21 bit branch that adjusts for gp loads. */
814 HOWTO (R_ALPHA_BRSGP
, /* type */
816 2, /* size (0 = byte, 1 = short, 2 = long) */
818 TRUE
, /* pc_relative */
820 complain_overflow_signed
, /* complain_on_overflow */
821 bfd_elf_generic_reloc
, /* special_function */
823 FALSE
, /* partial_inplace */
824 0x1fffff, /* src_mask */
825 0x1fffff, /* dst_mask */
826 TRUE
), /* pcrel_offset */
828 /* Creates a tls_index for the symbol in the got. */
829 HOWTO (R_ALPHA_TLSGD
, /* type */
831 1, /* size (0 = byte, 1 = short, 2 = long) */
833 FALSE
, /* pc_relative */
835 complain_overflow_signed
, /* complain_on_overflow */
836 bfd_elf_generic_reloc
, /* special_function */
838 FALSE
, /* partial_inplace */
839 0xffff, /* src_mask */
840 0xffff, /* dst_mask */
841 FALSE
), /* pcrel_offset */
843 /* Creates a tls_index for the (current) module in the got. */
844 HOWTO (R_ALPHA_TLSLDM
, /* type */
846 1, /* size (0 = byte, 1 = short, 2 = long) */
848 FALSE
, /* pc_relative */
850 complain_overflow_signed
, /* complain_on_overflow */
851 bfd_elf_generic_reloc
, /* special_function */
853 FALSE
, /* partial_inplace */
854 0xffff, /* src_mask */
855 0xffff, /* dst_mask */
856 FALSE
), /* pcrel_offset */
858 /* A dynamic relocation for a DTP module entry. */
859 HOWTO (R_ALPHA_DTPMOD64
, /* type */
861 4, /* size (0 = byte, 1 = short, 2 = long) */
863 FALSE
, /* pc_relative */
865 complain_overflow_bitfield
, /* complain_on_overflow */
866 bfd_elf_generic_reloc
, /* special_function */
867 "DTPMOD64", /* name */
868 FALSE
, /* partial_inplace */
869 MINUS_ONE
, /* src_mask */
870 MINUS_ONE
, /* dst_mask */
871 FALSE
), /* pcrel_offset */
873 /* Creates a 64-bit offset in the got for the displacement
874 from DTP to the target. */
875 HOWTO (R_ALPHA_GOTDTPREL
, /* type */
877 1, /* size (0 = byte, 1 = short, 2 = long) */
879 FALSE
, /* pc_relative */
881 complain_overflow_signed
, /* complain_on_overflow */
882 bfd_elf_generic_reloc
, /* special_function */
883 "GOTDTPREL", /* name */
884 FALSE
, /* partial_inplace */
885 0xffff, /* src_mask */
886 0xffff, /* dst_mask */
887 FALSE
), /* pcrel_offset */
889 /* A dynamic relocation for a displacement from DTP to the target. */
890 HOWTO (R_ALPHA_DTPREL64
, /* type */
892 4, /* size (0 = byte, 1 = short, 2 = long) */
894 FALSE
, /* pc_relative */
896 complain_overflow_bitfield
, /* complain_on_overflow */
897 bfd_elf_generic_reloc
, /* special_function */
898 "DTPREL64", /* name */
899 FALSE
, /* partial_inplace */
900 MINUS_ONE
, /* src_mask */
901 MINUS_ONE
, /* dst_mask */
902 FALSE
), /* pcrel_offset */
904 /* The high 16 bits of the displacement from DTP to the target. */
905 HOWTO (R_ALPHA_DTPRELHI
, /* type */
907 1, /* size (0 = byte, 1 = short, 2 = long) */
909 FALSE
, /* pc_relative */
911 complain_overflow_signed
, /* complain_on_overflow */
912 bfd_elf_generic_reloc
, /* special_function */
913 "DTPRELHI", /* name */
914 FALSE
, /* partial_inplace */
915 0xffff, /* src_mask */
916 0xffff, /* dst_mask */
917 FALSE
), /* pcrel_offset */
919 /* The low 16 bits of the displacement from DTP to the target. */
920 HOWTO (R_ALPHA_DTPRELLO
, /* type */
922 1, /* size (0 = byte, 1 = short, 2 = long) */
924 FALSE
, /* pc_relative */
926 complain_overflow_dont
, /* complain_on_overflow */
927 bfd_elf_generic_reloc
, /* special_function */
928 "DTPRELLO", /* name */
929 FALSE
, /* partial_inplace */
930 0xffff, /* src_mask */
931 0xffff, /* dst_mask */
932 FALSE
), /* pcrel_offset */
934 /* A 16-bit displacement from DTP to the target. */
935 HOWTO (R_ALPHA_DTPREL16
, /* type */
937 1, /* size (0 = byte, 1 = short, 2 = long) */
939 FALSE
, /* pc_relative */
941 complain_overflow_signed
, /* complain_on_overflow */
942 bfd_elf_generic_reloc
, /* special_function */
943 "DTPREL16", /* name */
944 FALSE
, /* partial_inplace */
945 0xffff, /* src_mask */
946 0xffff, /* dst_mask */
947 FALSE
), /* pcrel_offset */
949 /* Creates a 64-bit offset in the got for the displacement
950 from TP to the target. */
951 HOWTO (R_ALPHA_GOTTPREL
, /* type */
953 1, /* size (0 = byte, 1 = short, 2 = long) */
955 FALSE
, /* pc_relative */
957 complain_overflow_signed
, /* complain_on_overflow */
958 bfd_elf_generic_reloc
, /* special_function */
959 "GOTTPREL", /* name */
960 FALSE
, /* partial_inplace */
961 0xffff, /* src_mask */
962 0xffff, /* dst_mask */
963 FALSE
), /* pcrel_offset */
965 /* A dynamic relocation for a displacement from TP to the target. */
966 HOWTO (R_ALPHA_TPREL64
, /* type */
968 4, /* size (0 = byte, 1 = short, 2 = long) */
970 FALSE
, /* pc_relative */
972 complain_overflow_bitfield
, /* complain_on_overflow */
973 bfd_elf_generic_reloc
, /* special_function */
974 "TPREL64", /* name */
975 FALSE
, /* partial_inplace */
976 MINUS_ONE
, /* src_mask */
977 MINUS_ONE
, /* dst_mask */
978 FALSE
), /* pcrel_offset */
980 /* The high 16 bits of the displacement from TP to the target. */
981 HOWTO (R_ALPHA_TPRELHI
, /* type */
983 1, /* size (0 = byte, 1 = short, 2 = long) */
985 FALSE
, /* pc_relative */
987 complain_overflow_signed
, /* complain_on_overflow */
988 bfd_elf_generic_reloc
, /* special_function */
989 "TPRELHI", /* name */
990 FALSE
, /* partial_inplace */
991 0xffff, /* src_mask */
992 0xffff, /* dst_mask */
993 FALSE
), /* pcrel_offset */
995 /* The low 16 bits of the displacement from TP to the target. */
996 HOWTO (R_ALPHA_TPRELLO
, /* type */
998 1, /* size (0 = byte, 1 = short, 2 = long) */
1000 FALSE
, /* pc_relative */
1002 complain_overflow_dont
, /* complain_on_overflow */
1003 bfd_elf_generic_reloc
, /* special_function */
1004 "TPRELLO", /* name */
1005 FALSE
, /* partial_inplace */
1006 0xffff, /* src_mask */
1007 0xffff, /* dst_mask */
1008 FALSE
), /* pcrel_offset */
1010 /* A 16-bit displacement from TP to the target. */
1011 HOWTO (R_ALPHA_TPREL16
, /* type */
1013 1, /* size (0 = byte, 1 = short, 2 = long) */
1015 FALSE
, /* pc_relative */
1017 complain_overflow_signed
, /* complain_on_overflow */
1018 bfd_elf_generic_reloc
, /* special_function */
1019 "TPREL16", /* name */
1020 FALSE
, /* partial_inplace */
1021 0xffff, /* src_mask */
1022 0xffff, /* dst_mask */
1023 FALSE
), /* pcrel_offset */
1026 /* A mapping from BFD reloc types to Alpha ELF reloc types. */
1028 struct elf_reloc_map
1030 bfd_reloc_code_real_type bfd_reloc_val
;
1034 static const struct elf_reloc_map elf64_alpha_reloc_map
[] =
1036 {BFD_RELOC_NONE
, R_ALPHA_NONE
},
1037 {BFD_RELOC_32
, R_ALPHA_REFLONG
},
1038 {BFD_RELOC_64
, R_ALPHA_REFQUAD
},
1039 {BFD_RELOC_CTOR
, R_ALPHA_REFQUAD
},
1040 {BFD_RELOC_GPREL32
, R_ALPHA_GPREL32
},
1041 {BFD_RELOC_ALPHA_ELF_LITERAL
, R_ALPHA_LITERAL
},
1042 {BFD_RELOC_ALPHA_LITUSE
, R_ALPHA_LITUSE
},
1043 {BFD_RELOC_ALPHA_GPDISP
, R_ALPHA_GPDISP
},
1044 {BFD_RELOC_23_PCREL_S2
, R_ALPHA_BRADDR
},
1045 {BFD_RELOC_ALPHA_HINT
, R_ALPHA_HINT
},
1046 {BFD_RELOC_16_PCREL
, R_ALPHA_SREL16
},
1047 {BFD_RELOC_32_PCREL
, R_ALPHA_SREL32
},
1048 {BFD_RELOC_64_PCREL
, R_ALPHA_SREL64
},
1049 {BFD_RELOC_ALPHA_GPREL_HI16
, R_ALPHA_GPRELHIGH
},
1050 {BFD_RELOC_ALPHA_GPREL_LO16
, R_ALPHA_GPRELLOW
},
1051 {BFD_RELOC_GPREL16
, R_ALPHA_GPREL16
},
1052 {BFD_RELOC_ALPHA_BRSGP
, R_ALPHA_BRSGP
},
1053 {BFD_RELOC_ALPHA_TLSGD
, R_ALPHA_TLSGD
},
1054 {BFD_RELOC_ALPHA_TLSLDM
, R_ALPHA_TLSLDM
},
1055 {BFD_RELOC_ALPHA_DTPMOD64
, R_ALPHA_DTPMOD64
},
1056 {BFD_RELOC_ALPHA_GOTDTPREL16
, R_ALPHA_GOTDTPREL
},
1057 {BFD_RELOC_ALPHA_DTPREL64
, R_ALPHA_DTPREL64
},
1058 {BFD_RELOC_ALPHA_DTPREL_HI16
, R_ALPHA_DTPRELHI
},
1059 {BFD_RELOC_ALPHA_DTPREL_LO16
, R_ALPHA_DTPRELLO
},
1060 {BFD_RELOC_ALPHA_DTPREL16
, R_ALPHA_DTPREL16
},
1061 {BFD_RELOC_ALPHA_GOTTPREL16
, R_ALPHA_GOTTPREL
},
1062 {BFD_RELOC_ALPHA_TPREL64
, R_ALPHA_TPREL64
},
1063 {BFD_RELOC_ALPHA_TPREL_HI16
, R_ALPHA_TPRELHI
},
1064 {BFD_RELOC_ALPHA_TPREL_LO16
, R_ALPHA_TPRELLO
},
1065 {BFD_RELOC_ALPHA_TPREL16
, R_ALPHA_TPREL16
},
1068 /* Given a BFD reloc type, return a HOWTO structure. */
1070 static reloc_howto_type
*
1071 elf64_alpha_bfd_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1072 bfd_reloc_code_real_type code
)
1074 const struct elf_reloc_map
*i
, *e
;
1075 i
= e
= elf64_alpha_reloc_map
;
1076 e
+= sizeof (elf64_alpha_reloc_map
) / sizeof (struct elf_reloc_map
);
1079 if (i
->bfd_reloc_val
== code
)
1080 return &elf64_alpha_howto_table
[i
->elf_reloc_val
];
1085 static reloc_howto_type
*
1086 elf64_alpha_bfd_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1092 i
< (sizeof (elf64_alpha_howto_table
)
1093 / sizeof (elf64_alpha_howto_table
[0]));
1095 if (elf64_alpha_howto_table
[i
].name
!= NULL
1096 && strcasecmp (elf64_alpha_howto_table
[i
].name
, r_name
) == 0)
1097 return &elf64_alpha_howto_table
[i
];
1102 /* Given an Alpha ELF reloc type, fill in an arelent structure. */
1105 elf64_alpha_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
1106 Elf_Internal_Rela
*dst
)
1108 unsigned r_type
= ELF64_R_TYPE(dst
->r_info
);
1110 if (r_type
>= R_ALPHA_max
)
1112 /* xgettext:c-format */
1113 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1115 bfd_set_error (bfd_error_bad_value
);
1118 cache_ptr
->howto
= &elf64_alpha_howto_table
[r_type
];
1122 /* These two relocations create a two-word entry in the got. */
1123 #define alpha_got_entry_size(r_type) \
1124 (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1126 /* This is PT_TLS segment p_vaddr. */
1127 #define alpha_get_dtprel_base(info) \
1128 (elf_hash_table (info)->tls_sec->vma)
1130 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1131 is assigned offset round(16, PT_TLS p_align). */
1132 #define alpha_get_tprel_base(info) \
1133 (elf_hash_table (info)->tls_sec->vma \
1134 - align_power ((bfd_vma) 16, \
1135 elf_hash_table (info)->tls_sec->alignment_power))
1137 /* Handle an Alpha specific section when reading an object file. This
1138 is called when bfd_section_from_shdr finds a section with an unknown
1140 FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1144 elf64_alpha_section_from_shdr (bfd
*abfd
,
1145 Elf_Internal_Shdr
*hdr
,
1151 /* There ought to be a place to keep ELF backend specific flags, but
1152 at the moment there isn't one. We just keep track of the
1153 sections by their name, instead. Fortunately, the ABI gives
1154 suggested names for all the MIPS specific sections, so we will
1155 probably get away with this. */
1156 switch (hdr
->sh_type
)
1158 case SHT_ALPHA_DEBUG
:
1159 if (strcmp (name
, ".mdebug") != 0)
1166 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1168 newsect
= hdr
->bfd_section
;
1170 if (hdr
->sh_type
== SHT_ALPHA_DEBUG
)
1172 if (!bfd_set_section_flags (newsect
,
1173 bfd_section_flags (newsect
) | SEC_DEBUGGING
))
1180 /* Convert Alpha specific section flags to bfd internal section flags. */
1183 elf64_alpha_section_flags (flagword
*flags
, const Elf_Internal_Shdr
*hdr
)
1185 if (hdr
->sh_flags
& SHF_ALPHA_GPREL
)
1186 *flags
|= SEC_SMALL_DATA
;
1191 /* Set the correct type for an Alpha ELF section. We do this by the
1192 section name, which is a hack, but ought to work. */
1195 elf64_alpha_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
)
1197 register const char *name
;
1199 name
= bfd_section_name (sec
);
1201 if (strcmp (name
, ".mdebug") == 0)
1203 hdr
->sh_type
= SHT_ALPHA_DEBUG
;
1204 /* In a shared object on Irix 5.3, the .mdebug section has an
1205 entsize of 0. FIXME: Does this matter? */
1206 if ((abfd
->flags
& DYNAMIC
) != 0 )
1207 hdr
->sh_entsize
= 0;
1209 hdr
->sh_entsize
= 1;
1211 else if ((sec
->flags
& SEC_SMALL_DATA
)
1212 || strcmp (name
, ".sdata") == 0
1213 || strcmp (name
, ".sbss") == 0
1214 || strcmp (name
, ".lit4") == 0
1215 || strcmp (name
, ".lit8") == 0)
1216 hdr
->sh_flags
|= SHF_ALPHA_GPREL
;
1221 /* Hook called by the linker routine which adds symbols from an object
1222 file. We use it to put .comm items in .sbss, and not .bss. */
1225 elf64_alpha_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
1226 Elf_Internal_Sym
*sym
,
1227 const char **namep ATTRIBUTE_UNUSED
,
1228 flagword
*flagsp ATTRIBUTE_UNUSED
,
1229 asection
**secp
, bfd_vma
*valp
)
1231 if (sym
->st_shndx
== SHN_COMMON
1232 && !bfd_link_relocatable (info
)
1233 && sym
->st_size
<= elf_gp_size (abfd
))
1235 /* Common symbols less than or equal to -G nn bytes are
1236 automatically put into .sbss. */
1238 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1242 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 debug->ptr = (type) bfd_malloc (amt); \
1402 if (debug->ptr == NULL) \
1403 goto error_return; \
1404 if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0 \
1405 || bfd_bread (debug->ptr, amt, abfd) != amt) \
1406 goto error_return; \
1409 READ (line
, cbLineOffset
, cbLine
, sizeof (unsigned char), unsigned char *);
1410 READ (external_dnr
, cbDnOffset
, idnMax
, swap
->external_dnr_size
, void *);
1411 READ (external_pdr
, cbPdOffset
, ipdMax
, swap
->external_pdr_size
, void *);
1412 READ (external_sym
, cbSymOffset
, isymMax
, swap
->external_sym_size
, void *);
1413 READ (external_opt
, cbOptOffset
, ioptMax
, swap
->external_opt_size
, void *);
1414 READ (external_aux
, cbAuxOffset
, iauxMax
, sizeof (union aux_ext
),
1416 READ (ss
, cbSsOffset
, issMax
, sizeof (char), char *);
1417 READ (ssext
, cbSsExtOffset
, issExtMax
, sizeof (char), char *);
1418 READ (external_fdr
, cbFdOffset
, ifdMax
, swap
->external_fdr_size
, void *);
1419 READ (external_rfd
, cbRfdOffset
, crfd
, swap
->external_rfd_size
, void *);
1420 READ (external_ext
, cbExtOffset
, iextMax
, swap
->external_ext_size
, void *);
1428 if (ext_hdr
!= NULL
)
1430 if (debug
->line
!= NULL
)
1432 if (debug
->external_dnr
!= NULL
)
1433 free (debug
->external_dnr
);
1434 if (debug
->external_pdr
!= NULL
)
1435 free (debug
->external_pdr
);
1436 if (debug
->external_sym
!= NULL
)
1437 free (debug
->external_sym
);
1438 if (debug
->external_opt
!= NULL
)
1439 free (debug
->external_opt
);
1440 if (debug
->external_aux
!= NULL
)
1441 free (debug
->external_aux
);
1442 if (debug
->ss
!= NULL
)
1444 if (debug
->ssext
!= NULL
)
1445 free (debug
->ssext
);
1446 if (debug
->external_fdr
!= NULL
)
1447 free (debug
->external_fdr
);
1448 if (debug
->external_rfd
!= NULL
)
1449 free (debug
->external_rfd
);
1450 if (debug
->external_ext
!= NULL
)
1451 free (debug
->external_ext
);
1455 /* Alpha ELF local labels start with '$'. */
1458 elf64_alpha_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
, const char *name
)
1460 return name
[0] == '$';
1464 elf64_alpha_find_nearest_line (bfd
*abfd
, asymbol
**symbols
,
1465 asection
*section
, bfd_vma offset
,
1466 const char **filename_ptr
,
1467 const char **functionname_ptr
,
1468 unsigned int *line_ptr
,
1469 unsigned int *discriminator_ptr
)
1473 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
1474 filename_ptr
, functionname_ptr
,
1475 line_ptr
, discriminator_ptr
,
1476 dwarf_debug_sections
,
1477 &elf_tdata (abfd
)->dwarf2_find_line_info
)
1481 msec
= bfd_get_section_by_name (abfd
, ".mdebug");
1485 struct alpha_elf_find_line
*fi
;
1486 const struct ecoff_debug_swap
* const swap
=
1487 get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1489 /* If we are called during a link, alpha_elf_final_link may have
1490 cleared the SEC_HAS_CONTENTS field. We force it back on here
1491 if appropriate (which it normally will be). */
1492 origflags
= msec
->flags
;
1493 if (elf_section_data (msec
)->this_hdr
.sh_type
!= SHT_NOBITS
)
1494 msec
->flags
|= SEC_HAS_CONTENTS
;
1496 fi
= alpha_elf_tdata (abfd
)->find_line_info
;
1499 bfd_size_type external_fdr_size
;
1502 struct fdr
*fdr_ptr
;
1503 bfd_size_type amt
= sizeof (struct alpha_elf_find_line
);
1505 fi
= (struct alpha_elf_find_line
*) bfd_zalloc (abfd
, amt
);
1508 msec
->flags
= origflags
;
1512 if (!elf64_alpha_read_ecoff_info (abfd
, msec
, &fi
->d
))
1514 msec
->flags
= origflags
;
1518 /* Swap in the FDR information. */
1519 amt
= fi
->d
.symbolic_header
.ifdMax
* sizeof (struct fdr
);
1520 fi
->d
.fdr
= (struct fdr
*) bfd_alloc (abfd
, amt
);
1521 if (fi
->d
.fdr
== NULL
)
1523 msec
->flags
= origflags
;
1526 external_fdr_size
= swap
->external_fdr_size
;
1527 fdr_ptr
= fi
->d
.fdr
;
1528 fraw_src
= (char *) fi
->d
.external_fdr
;
1529 fraw_end
= (fraw_src
1530 + fi
->d
.symbolic_header
.ifdMax
* external_fdr_size
);
1531 for (; fraw_src
< fraw_end
; fraw_src
+= external_fdr_size
, fdr_ptr
++)
1532 (*swap
->swap_fdr_in
) (abfd
, fraw_src
, fdr_ptr
);
1534 alpha_elf_tdata (abfd
)->find_line_info
= fi
;
1536 /* Note that we don't bother to ever free this information.
1537 find_nearest_line is either called all the time, as in
1538 objdump -l, so the information should be saved, or it is
1539 rarely called, as in ld error messages, so the memory
1540 wasted is unimportant. Still, it would probably be a
1541 good idea for free_cached_info to throw it away. */
1544 if (_bfd_ecoff_locate_line (abfd
, section
, offset
, &fi
->d
, swap
,
1545 &fi
->i
, filename_ptr
, functionname_ptr
,
1548 msec
->flags
= origflags
;
1552 msec
->flags
= origflags
;
1555 /* Fall back on the generic ELF find_nearest_line routine. */
1557 return _bfd_elf_find_nearest_line (abfd
, symbols
, section
, offset
,
1558 filename_ptr
, functionname_ptr
,
1559 line_ptr
, discriminator_ptr
);
1562 /* Structure used to pass information to alpha_elf_output_extsym. */
1567 struct bfd_link_info
*info
;
1568 struct ecoff_debug_info
*debug
;
1569 const struct ecoff_debug_swap
*swap
;
1574 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry
*h
, void * data
)
1576 struct extsym_info
*einfo
= (struct extsym_info
*) data
;
1578 asection
*sec
, *output_section
;
1580 if (h
->root
.indx
== -2)
1582 else if ((h
->root
.def_dynamic
1583 || h
->root
.ref_dynamic
1584 || h
->root
.root
.type
== bfd_link_hash_new
)
1585 && !h
->root
.def_regular
1586 && !h
->root
.ref_regular
)
1588 else if (einfo
->info
->strip
== strip_all
1589 || (einfo
->info
->strip
== strip_some
1590 && bfd_hash_lookup (einfo
->info
->keep_hash
,
1591 h
->root
.root
.root
.string
,
1592 FALSE
, FALSE
) == NULL
))
1600 if (h
->esym
.ifd
== -2)
1603 h
->esym
.cobol_main
= 0;
1604 h
->esym
.weakext
= 0;
1605 h
->esym
.reserved
= 0;
1606 h
->esym
.ifd
= ifdNil
;
1607 h
->esym
.asym
.value
= 0;
1608 h
->esym
.asym
.st
= stGlobal
;
1610 if (h
->root
.root
.type
!= bfd_link_hash_defined
1611 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1612 h
->esym
.asym
.sc
= scAbs
;
1617 sec
= h
->root
.root
.u
.def
.section
;
1618 output_section
= sec
->output_section
;
1620 /* When making a shared library and symbol h is the one from
1621 the another shared library, OUTPUT_SECTION may be null. */
1622 if (output_section
== NULL
)
1623 h
->esym
.asym
.sc
= scUndefined
;
1626 name
= bfd_section_name (output_section
);
1628 if (strcmp (name
, ".text") == 0)
1629 h
->esym
.asym
.sc
= scText
;
1630 else if (strcmp (name
, ".data") == 0)
1631 h
->esym
.asym
.sc
= scData
;
1632 else if (strcmp (name
, ".sdata") == 0)
1633 h
->esym
.asym
.sc
= scSData
;
1634 else if (strcmp (name
, ".rodata") == 0
1635 || strcmp (name
, ".rdata") == 0)
1636 h
->esym
.asym
.sc
= scRData
;
1637 else if (strcmp (name
, ".bss") == 0)
1638 h
->esym
.asym
.sc
= scBss
;
1639 else if (strcmp (name
, ".sbss") == 0)
1640 h
->esym
.asym
.sc
= scSBss
;
1641 else if (strcmp (name
, ".init") == 0)
1642 h
->esym
.asym
.sc
= scInit
;
1643 else if (strcmp (name
, ".fini") == 0)
1644 h
->esym
.asym
.sc
= scFini
;
1646 h
->esym
.asym
.sc
= scAbs
;
1650 h
->esym
.asym
.reserved
= 0;
1651 h
->esym
.asym
.index
= indexNil
;
1654 if (h
->root
.root
.type
== bfd_link_hash_common
)
1655 h
->esym
.asym
.value
= h
->root
.root
.u
.c
.size
;
1656 else if (h
->root
.root
.type
== bfd_link_hash_defined
1657 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1659 if (h
->esym
.asym
.sc
== scCommon
)
1660 h
->esym
.asym
.sc
= scBss
;
1661 else if (h
->esym
.asym
.sc
== scSCommon
)
1662 h
->esym
.asym
.sc
= scSBss
;
1664 sec
= h
->root
.root
.u
.def
.section
;
1665 output_section
= sec
->output_section
;
1666 if (output_section
!= NULL
)
1667 h
->esym
.asym
.value
= (h
->root
.root
.u
.def
.value
1668 + sec
->output_offset
1669 + output_section
->vma
);
1671 h
->esym
.asym
.value
= 0;
1674 if (! bfd_ecoff_debug_one_external (einfo
->abfd
, einfo
->debug
, einfo
->swap
,
1675 h
->root
.root
.root
.string
,
1678 einfo
->failed
= TRUE
;
1685 /* Search for and possibly create a got entry. */
1687 static struct alpha_elf_got_entry
*
1688 get_got_entry (bfd
*abfd
, struct alpha_elf_link_hash_entry
*h
,
1689 unsigned long r_type
, unsigned long r_symndx
,
1692 struct alpha_elf_got_entry
*gotent
;
1693 struct alpha_elf_got_entry
**slot
;
1696 slot
= &h
->got_entries
;
1699 /* This is a local .got entry -- record for merge. */
1701 struct alpha_elf_got_entry
**local_got_entries
;
1703 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
1704 if (!local_got_entries
)
1707 Elf_Internal_Shdr
*symtab_hdr
;
1709 symtab_hdr
= &elf_tdata(abfd
)->symtab_hdr
;
1710 size
= symtab_hdr
->sh_info
;
1711 size
*= sizeof (struct alpha_elf_got_entry
*);
1714 = (struct alpha_elf_got_entry
**) bfd_zalloc (abfd
, size
);
1715 if (!local_got_entries
)
1718 alpha_elf_tdata (abfd
)->local_got_entries
= local_got_entries
;
1721 slot
= &local_got_entries
[r_symndx
];
1724 for (gotent
= *slot
; gotent
; gotent
= gotent
->next
)
1725 if (gotent
->gotobj
== abfd
1726 && gotent
->reloc_type
== r_type
1727 && gotent
->addend
== r_addend
)
1735 amt
= sizeof (struct alpha_elf_got_entry
);
1736 gotent
= (struct alpha_elf_got_entry
*) bfd_alloc (abfd
, amt
);
1740 gotent
->gotobj
= abfd
;
1741 gotent
->addend
= r_addend
;
1742 gotent
->got_offset
= -1;
1743 gotent
->plt_offset
= -1;
1744 gotent
->use_count
= 1;
1745 gotent
->reloc_type
= r_type
;
1746 gotent
->reloc_done
= 0;
1747 gotent
->reloc_xlated
= 0;
1749 gotent
->next
= *slot
;
1752 entry_size
= alpha_got_entry_size (r_type
);
1753 alpha_elf_tdata (abfd
)->total_got_size
+= entry_size
;
1755 alpha_elf_tdata(abfd
)->local_got_size
+= entry_size
;
1758 gotent
->use_count
+= 1;
1764 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry
*ah
)
1766 return ((ah
->root
.type
== STT_FUNC
1767 || ah
->root
.root
.type
== bfd_link_hash_undefweak
1768 || ah
->root
.root
.type
== bfd_link_hash_undefined
)
1769 && (ah
->flags
& ALPHA_ELF_LINK_HASH_LU_PLT
) != 0
1770 && (ah
->flags
& ~ALPHA_ELF_LINK_HASH_LU_PLT
) == 0);
1773 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
1774 Don't do so for code sections. We want to keep ordering of LITERAL/LITUSE
1775 as is. On the other hand, elf-eh-frame.c processing requires .eh_frame
1776 relocs to be sorted. */
1779 elf64_alpha_sort_relocs_p (asection
*sec
)
1781 return (sec
->flags
& SEC_CODE
) == 0;
1785 /* Handle dynamic relocations when doing an Alpha ELF link. */
1788 elf64_alpha_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1789 asection
*sec
, const Elf_Internal_Rela
*relocs
)
1793 Elf_Internal_Shdr
*symtab_hdr
;
1794 struct alpha_elf_link_hash_entry
**sym_hashes
;
1795 const Elf_Internal_Rela
*rel
, *relend
;
1797 if (bfd_link_relocatable (info
))
1800 /* Don't do anything special with non-loaded, non-alloced sections.
1801 In particular, any relocs in such sections should not affect GOT
1802 and PLT reference counting (ie. we don't allow them to create GOT
1803 or PLT entries), there's no possibility or desire to optimize TLS
1804 relocs, and there's not much point in propagating relocs to shared
1805 libs that the dynamic linker won't relocate. */
1806 if ((sec
->flags
& SEC_ALLOC
) == 0)
1809 BFD_ASSERT (is_alpha_elf (abfd
));
1811 dynobj
= elf_hash_table (info
)->dynobj
;
1813 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1816 symtab_hdr
= &elf_symtab_hdr (abfd
);
1817 sym_hashes
= alpha_elf_sym_hashes (abfd
);
1819 relend
= relocs
+ sec
->reloc_count
;
1820 for (rel
= relocs
; rel
< relend
; ++rel
)
1828 unsigned long r_symndx
, r_type
;
1829 struct alpha_elf_link_hash_entry
*h
;
1830 unsigned int gotent_flags
;
1831 bfd_boolean maybe_dynamic
;
1835 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1836 if (r_symndx
< symtab_hdr
->sh_info
)
1840 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1842 while (h
->root
.root
.type
== bfd_link_hash_indirect
1843 || h
->root
.root
.type
== bfd_link_hash_warning
)
1844 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
1846 /* PR15323, ref flags aren't set for references in the same
1848 h
->root
.ref_regular
= 1;
1851 /* We can only get preliminary data on whether a symbol is
1852 locally or externally defined, as not all of the input files
1853 have yet been processed. Do something with what we know, as
1854 this may help reduce memory usage and processing time later. */
1855 maybe_dynamic
= FALSE
;
1856 if (h
&& ((bfd_link_pic (info
)
1858 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
1859 || !h
->root
.def_regular
1860 || h
->root
.root
.type
== bfd_link_hash_defweak
))
1861 maybe_dynamic
= TRUE
;
1865 r_type
= ELF64_R_TYPE (rel
->r_info
);
1866 addend
= rel
->r_addend
;
1870 case R_ALPHA_LITERAL
:
1871 need
= NEED_GOT
| NEED_GOT_ENTRY
;
1873 /* Remember how this literal is used from its LITUSEs.
1874 This will be important when it comes to decide if we can
1875 create a .plt entry for a function symbol. */
1876 while (++rel
< relend
&& ELF64_R_TYPE (rel
->r_info
) == R_ALPHA_LITUSE
)
1877 if (rel
->r_addend
>= 1 && rel
->r_addend
<= 6)
1878 gotent_flags
|= 1 << rel
->r_addend
;
1881 /* No LITUSEs -- presumably the address is used somehow. */
1882 if (gotent_flags
== 0)
1883 gotent_flags
= ALPHA_ELF_LINK_HASH_LU_ADDR
;
1886 case R_ALPHA_GPDISP
:
1887 case R_ALPHA_GPREL16
:
1888 case R_ALPHA_GPREL32
:
1889 case R_ALPHA_GPRELHIGH
:
1890 case R_ALPHA_GPRELLOW
:
1895 case R_ALPHA_REFLONG
:
1896 case R_ALPHA_REFQUAD
:
1897 if (bfd_link_pic (info
) || maybe_dynamic
)
1901 case R_ALPHA_TLSLDM
:
1902 /* The symbol for a TLSLDM reloc is ignored. Collapse the
1903 reloc to the STN_UNDEF (0) symbol so that they all match. */
1904 r_symndx
= STN_UNDEF
;
1906 maybe_dynamic
= FALSE
;
1910 case R_ALPHA_GOTDTPREL
:
1911 need
= NEED_GOT
| NEED_GOT_ENTRY
;
1914 case R_ALPHA_GOTTPREL
:
1915 need
= NEED_GOT
| NEED_GOT_ENTRY
;
1916 gotent_flags
= ALPHA_ELF_LINK_HASH_TLS_IE
;
1917 if (bfd_link_pic (info
))
1918 info
->flags
|= DF_STATIC_TLS
;
1921 case R_ALPHA_TPREL64
:
1922 if (bfd_link_dll (info
))
1924 info
->flags
|= DF_STATIC_TLS
;
1927 else if (maybe_dynamic
)
1932 if (need
& NEED_GOT
)
1934 if (alpha_elf_tdata(abfd
)->gotobj
== NULL
)
1936 if (!elf64_alpha_create_got_section (abfd
, info
))
1941 if (need
& NEED_GOT_ENTRY
)
1943 struct alpha_elf_got_entry
*gotent
;
1945 gotent
= get_got_entry (abfd
, h
, r_type
, r_symndx
, addend
);
1951 gotent
->flags
|= gotent_flags
;
1954 gotent_flags
|= h
->flags
;
1955 h
->flags
= gotent_flags
;
1957 /* Make a guess as to whether a .plt entry is needed. */
1958 /* ??? It appears that we won't make it into
1959 adjust_dynamic_symbol for symbols that remain
1960 totally undefined. Copying this check here means
1961 we can create a plt entry for them too. */
1963 = (maybe_dynamic
&& elf64_alpha_want_plt (h
));
1968 if (need
& NEED_DYNREL
)
1970 /* We need to create the section here now whether we eventually
1971 use it or not so that it gets mapped to an output section by
1972 the linker. If not used, we'll kill it in size_dynamic_sections. */
1975 sreloc
= _bfd_elf_make_dynamic_reloc_section
1976 (sec
, dynobj
, 3, abfd
, /*rela?*/ TRUE
);
1984 /* Since we havn't seen all of the input symbols yet, we
1985 don't know whether we'll actually need a dynamic relocation
1986 entry for this reloc. So make a record of it. Once we
1987 find out if this thing needs dynamic relocation we'll
1988 expand the relocation sections by the appropriate amount. */
1990 struct alpha_elf_reloc_entry
*rent
;
1992 for (rent
= h
->reloc_entries
; rent
; rent
= rent
->next
)
1993 if (rent
->rtype
== r_type
&& rent
->srel
== sreloc
)
1998 size_t amt
= sizeof (struct alpha_elf_reloc_entry
);
1999 rent
= (struct alpha_elf_reloc_entry
*) bfd_alloc (abfd
, amt
);
2003 rent
->srel
= sreloc
;
2004 rent
->rtype
= r_type
;
2006 rent
->reltext
= (sec
->flags
& SEC_READONLY
) != 0;
2008 rent
->next
= h
->reloc_entries
;
2009 h
->reloc_entries
= rent
;
2014 else if (bfd_link_pic (info
))
2016 /* If this is a shared library, and the section is to be
2017 loaded into memory, we need a RELATIVE reloc. */
2018 sreloc
->size
+= sizeof (Elf64_External_Rela
);
2019 if (sec
->flags
& SEC_READONLY
)
2020 info
->flags
|= DF_TEXTREL
;
2028 /* Return the section that should be marked against GC for a given
2032 elf64_alpha_gc_mark_hook (asection
*sec
, struct bfd_link_info
*info
,
2033 Elf_Internal_Rela
*rel
,
2034 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
)
2036 /* These relocations don't really reference a symbol. Instead we store
2037 extra data in their addend slot. Ignore the symbol. */
2038 switch (ELF64_R_TYPE (rel
->r_info
))
2040 case R_ALPHA_LITUSE
:
2041 case R_ALPHA_GPDISP
:
2046 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2049 /* Adjust a symbol defined by a dynamic object and referenced by a
2050 regular object. The current definition is in some section of the
2051 dynamic object, but we're not including those sections. We have to
2052 change the definition to something the rest of the link can
2056 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2057 struct elf_link_hash_entry
*h
)
2061 struct alpha_elf_link_hash_entry
*ah
;
2063 dynobj
= elf_hash_table(info
)->dynobj
;
2064 ah
= (struct alpha_elf_link_hash_entry
*)h
;
2066 /* Now that we've seen all of the input symbols, finalize our decision
2067 about whether this symbol should get a .plt entry. Irritatingly, it
2068 is common for folk to leave undefined symbols in shared libraries,
2069 and they still expect lazy binding; accept undefined symbols in lieu
2071 if (alpha_elf_dynamic_symbol_p (h
, info
) && elf64_alpha_want_plt (ah
))
2073 h
->needs_plt
= TRUE
;
2075 s
= elf_hash_table(info
)->splt
;
2076 if (!s
&& !elf64_alpha_create_dynamic_sections (dynobj
, info
))
2079 /* We need one plt entry per got subsection. Delay allocation of
2080 the actual plt entries until size_plt_section, called from
2081 size_dynamic_sections or during relaxation. */
2086 h
->needs_plt
= FALSE
;
2088 /* If this is a weak symbol, and there is a real definition, the
2089 processor independent code will have arranged for us to see the
2090 real definition first, and we can just use the same value. */
2091 if (h
->is_weakalias
)
2093 struct elf_link_hash_entry
*def
= weakdef (h
);
2094 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2095 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2096 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2100 /* This is a reference to a symbol defined by a dynamic object which
2101 is not a function. The Alpha, since it uses .got entries for all
2102 symbols even in regular objects, does not need the hackery of a
2103 .dynbss section and COPY dynamic relocations. */
2108 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD. */
2111 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
2112 const Elf_Internal_Sym
*isym
,
2113 bfd_boolean definition
,
2114 bfd_boolean dynamic
)
2116 if (!dynamic
&& definition
)
2117 h
->other
= ((h
->other
& ELF_ST_VISIBILITY (-1))
2118 | (isym
->st_other
& ~ELF_ST_VISIBILITY (-1)));
2121 /* Symbol versioning can create new symbols, and make our old symbols
2122 indirect to the new ones. Consolidate the got and reloc information
2123 in these situations. */
2126 elf64_alpha_copy_indirect_symbol (struct bfd_link_info
*info
,
2127 struct elf_link_hash_entry
*dir
,
2128 struct elf_link_hash_entry
*ind
)
2130 struct alpha_elf_link_hash_entry
*hi
2131 = (struct alpha_elf_link_hash_entry
*) ind
;
2132 struct alpha_elf_link_hash_entry
*hs
2133 = (struct alpha_elf_link_hash_entry
*) dir
;
2135 /* Do the merging in the superclass. */
2136 _bfd_elf_link_hash_copy_indirect(info
, dir
, ind
);
2138 /* Merge the flags. Whee. */
2139 hs
->flags
|= hi
->flags
;
2141 /* ??? It's unclear to me what's really supposed to happen when
2142 "merging" defweak and defined symbols, given that we don't
2143 actually throw away the defweak. This more-or-less copies
2144 the logic related to got and plt entries in the superclass. */
2145 if (ind
->root
.type
!= bfd_link_hash_indirect
)
2148 /* Merge the .got entries. Cannibalize the old symbol's list in
2149 doing so, since we don't need it anymore. */
2151 if (hs
->got_entries
== NULL
)
2152 hs
->got_entries
= hi
->got_entries
;
2155 struct alpha_elf_got_entry
*gi
, *gs
, *gin
, *gsh
;
2157 gsh
= hs
->got_entries
;
2158 for (gi
= hi
->got_entries
; gi
; gi
= gin
)
2161 for (gs
= gsh
; gs
; gs
= gs
->next
)
2162 if (gi
->gotobj
== gs
->gotobj
2163 && gi
->reloc_type
== gs
->reloc_type
2164 && gi
->addend
== gs
->addend
)
2166 gs
->use_count
+= gi
->use_count
;
2169 gi
->next
= hs
->got_entries
;
2170 hs
->got_entries
= gi
;
2174 hi
->got_entries
= NULL
;
2176 /* And similar for the reloc entries. */
2178 if (hs
->reloc_entries
== NULL
)
2179 hs
->reloc_entries
= hi
->reloc_entries
;
2182 struct alpha_elf_reloc_entry
*ri
, *rs
, *rin
, *rsh
;
2184 rsh
= hs
->reloc_entries
;
2185 for (ri
= hi
->reloc_entries
; ri
; ri
= rin
)
2188 for (rs
= rsh
; rs
; rs
= rs
->next
)
2189 if (ri
->rtype
== rs
->rtype
&& ri
->srel
== rs
->srel
)
2191 rs
->count
+= ri
->count
;
2194 ri
->next
= hs
->reloc_entries
;
2195 hs
->reloc_entries
= ri
;
2199 hi
->reloc_entries
= NULL
;
2202 /* Is it possible to merge two object file's .got tables? */
2205 elf64_alpha_can_merge_gots (bfd
*a
, bfd
*b
)
2207 int total
= alpha_elf_tdata (a
)->total_got_size
;
2210 /* Trivial quick fallout test. */
2211 if (total
+ alpha_elf_tdata (b
)->total_got_size
<= MAX_GOT_SIZE
)
2214 /* By their nature, local .got entries cannot be merged. */
2215 if ((total
+= alpha_elf_tdata (b
)->local_got_size
) > MAX_GOT_SIZE
)
2218 /* Failing the common trivial comparison, we must effectively
2219 perform the merge. Not actually performing the merge means that
2220 we don't have to store undo information in case we fail. */
2221 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2223 struct alpha_elf_link_hash_entry
**hashes
= alpha_elf_sym_hashes (bsub
);
2224 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2227 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
2228 for (i
= 0; i
< n
; ++i
)
2230 struct alpha_elf_got_entry
*ae
, *be
;
2231 struct alpha_elf_link_hash_entry
*h
;
2234 while (h
->root
.root
.type
== bfd_link_hash_indirect
2235 || h
->root
.root
.type
== bfd_link_hash_warning
)
2236 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2238 for (be
= h
->got_entries
; be
; be
= be
->next
)
2240 if (be
->use_count
== 0)
2242 if (be
->gotobj
!= b
)
2245 for (ae
= h
->got_entries
; ae
; ae
= ae
->next
)
2247 && ae
->reloc_type
== be
->reloc_type
2248 && ae
->addend
== be
->addend
)
2251 total
+= alpha_got_entry_size (be
->reloc_type
);
2252 if (total
> MAX_GOT_SIZE
)
2262 /* Actually merge two .got tables. */
2265 elf64_alpha_merge_gots (bfd
*a
, bfd
*b
)
2267 int total
= alpha_elf_tdata (a
)->total_got_size
;
2270 /* Remember local expansion. */
2272 int e
= alpha_elf_tdata (b
)->local_got_size
;
2274 alpha_elf_tdata (a
)->local_got_size
+= e
;
2277 for (bsub
= b
; bsub
; bsub
= alpha_elf_tdata (bsub
)->in_got_link_next
)
2279 struct alpha_elf_got_entry
**local_got_entries
;
2280 struct alpha_elf_link_hash_entry
**hashes
;
2281 Elf_Internal_Shdr
*symtab_hdr
;
2284 /* Let the local .got entries know they are part of a new subsegment. */
2285 local_got_entries
= alpha_elf_tdata (bsub
)->local_got_entries
;
2286 if (local_got_entries
)
2288 n
= elf_tdata (bsub
)->symtab_hdr
.sh_info
;
2289 for (i
= 0; i
< n
; ++i
)
2291 struct alpha_elf_got_entry
*ent
;
2292 for (ent
= local_got_entries
[i
]; ent
; ent
= ent
->next
)
2297 /* Merge the global .got entries. */
2298 hashes
= alpha_elf_sym_hashes (bsub
);
2299 symtab_hdr
= &elf_tdata (bsub
)->symtab_hdr
;
2301 n
= NUM_SHDR_ENTRIES (symtab_hdr
) - symtab_hdr
->sh_info
;
2302 for (i
= 0; i
< n
; ++i
)
2304 struct alpha_elf_got_entry
*ae
, *be
, **pbe
, **start
;
2305 struct alpha_elf_link_hash_entry
*h
;
2308 while (h
->root
.root
.type
== bfd_link_hash_indirect
2309 || h
->root
.root
.type
== bfd_link_hash_warning
)
2310 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
2312 pbe
= start
= &h
->got_entries
;
2313 while ((be
= *pbe
) != NULL
)
2315 if (be
->use_count
== 0)
2318 memset (be
, 0xa5, sizeof (*be
));
2321 if (be
->gotobj
!= b
)
2324 for (ae
= *start
; ae
; ae
= ae
->next
)
2326 && ae
->reloc_type
== be
->reloc_type
2327 && ae
->addend
== be
->addend
)
2329 ae
->flags
|= be
->flags
;
2330 ae
->use_count
+= be
->use_count
;
2332 memset (be
, 0xa5, sizeof (*be
));
2336 total
+= alpha_got_entry_size (be
->reloc_type
);
2344 alpha_elf_tdata (bsub
)->gotobj
= a
;
2346 alpha_elf_tdata (a
)->total_got_size
= total
;
2348 /* Merge the two in_got chains. */
2353 while ((next
= alpha_elf_tdata (bsub
)->in_got_link_next
) != NULL
)
2356 alpha_elf_tdata (bsub
)->in_got_link_next
= b
;
2360 /* Calculate the offsets for the got entries. */
2363 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry
*h
,
2364 void * arg ATTRIBUTE_UNUSED
)
2366 struct alpha_elf_got_entry
*gotent
;
2368 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2369 if (gotent
->use_count
> 0)
2371 struct alpha_elf_obj_tdata
*td
;
2372 bfd_size_type
*plge
;
2374 td
= alpha_elf_tdata (gotent
->gotobj
);
2375 plge
= &td
->got
->size
;
2376 gotent
->got_offset
= *plge
;
2377 *plge
+= alpha_got_entry_size (gotent
->reloc_type
);
2384 elf64_alpha_calc_got_offsets (struct bfd_link_info
*info
)
2387 struct alpha_elf_link_hash_table
* htab
;
2389 htab
= alpha_elf_hash_table (info
);
2392 got_list
= htab
->got_list
;
2394 /* First, zero out the .got sizes, as we may be recalculating the
2395 .got after optimizing it. */
2396 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2397 alpha_elf_tdata(i
)->got
->size
= 0;
2399 /* Next, fill in the offsets for all the global entries. */
2400 alpha_elf_link_hash_traverse (htab
,
2401 elf64_alpha_calc_got_offsets_for_symbol
,
2404 /* Finally, fill in the offsets for the local entries. */
2405 for (i
= got_list
; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2407 bfd_size_type got_offset
= alpha_elf_tdata(i
)->got
->size
;
2410 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
2412 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
2415 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
2416 if (!local_got_entries
)
2419 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
2420 for (gotent
= local_got_entries
[k
]; gotent
; gotent
= gotent
->next
)
2421 if (gotent
->use_count
> 0)
2423 gotent
->got_offset
= got_offset
;
2424 got_offset
+= alpha_got_entry_size (gotent
->reloc_type
);
2428 alpha_elf_tdata(i
)->got
->size
= got_offset
;
2432 /* Constructs the gots. */
2435 elf64_alpha_size_got_sections (struct bfd_link_info
*info
,
2436 bfd_boolean may_merge
)
2438 bfd
*i
, *got_list
, *cur_got_obj
= NULL
;
2439 struct alpha_elf_link_hash_table
* htab
;
2441 htab
= alpha_elf_hash_table (info
);
2444 got_list
= htab
->got_list
;
2446 /* On the first time through, pretend we have an existing got list
2447 consisting of all of the input files. */
2448 if (got_list
== NULL
)
2450 for (i
= info
->input_bfds
; i
; i
= i
->link
.next
)
2454 if (! is_alpha_elf (i
))
2457 this_got
= alpha_elf_tdata (i
)->gotobj
;
2458 if (this_got
== NULL
)
2461 /* We are assuming no merging has yet occurred. */
2462 BFD_ASSERT (this_got
== i
);
2464 if (alpha_elf_tdata (this_got
)->total_got_size
> MAX_GOT_SIZE
)
2466 /* Yikes! A single object file has too many entries. */
2468 /* xgettext:c-format */
2469 (_("%pB: .got subsegment exceeds 64K (size %d)"),
2470 i
, alpha_elf_tdata (this_got
)->total_got_size
);
2474 if (got_list
== NULL
)
2475 got_list
= this_got
;
2477 alpha_elf_tdata(cur_got_obj
)->got_link_next
= this_got
;
2478 cur_got_obj
= this_got
;
2481 /* Strange degenerate case of no got references. */
2482 if (got_list
== NULL
)
2485 htab
->got_list
= got_list
;
2488 cur_got_obj
= got_list
;
2489 if (cur_got_obj
== NULL
)
2494 i
= alpha_elf_tdata(cur_got_obj
)->got_link_next
;
2497 if (elf64_alpha_can_merge_gots (cur_got_obj
, i
))
2499 elf64_alpha_merge_gots (cur_got_obj
, i
);
2501 alpha_elf_tdata(i
)->got
->size
= 0;
2502 i
= alpha_elf_tdata(i
)->got_link_next
;
2503 alpha_elf_tdata(cur_got_obj
)->got_link_next
= i
;
2508 i
= alpha_elf_tdata(i
)->got_link_next
;
2513 /* Once the gots have been merged, fill in the got offsets for
2514 everything therein. */
2515 elf64_alpha_calc_got_offsets (info
);
2521 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry
*h
,
2524 asection
*splt
= (asection
*) data
;
2525 struct alpha_elf_got_entry
*gotent
;
2526 bfd_boolean saw_one
= FALSE
;
2528 /* If we didn't need an entry before, we still don't. */
2529 if (!h
->root
.needs_plt
)
2532 /* For each LITERAL got entry still in use, allocate a plt entry. */
2533 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2534 if (gotent
->reloc_type
== R_ALPHA_LITERAL
2535 && gotent
->use_count
> 0)
2537 if (splt
->size
== 0)
2538 splt
->size
= PLT_HEADER_SIZE
;
2539 gotent
->plt_offset
= splt
->size
;
2540 splt
->size
+= PLT_ENTRY_SIZE
;
2544 /* If there weren't any, there's no longer a need for the PLT entry. */
2546 h
->root
.needs_plt
= FALSE
;
2551 /* Called from relax_section to rebuild the PLT in light of potential changes
2552 in the function's status. */
2555 elf64_alpha_size_plt_section (struct bfd_link_info
*info
)
2557 asection
*splt
, *spltrel
, *sgotplt
;
2558 unsigned long entries
;
2559 struct alpha_elf_link_hash_table
* htab
;
2561 htab
= alpha_elf_hash_table (info
);
2565 splt
= elf_hash_table(info
)->splt
;
2571 alpha_elf_link_hash_traverse (htab
,
2572 elf64_alpha_size_plt_section_1
, splt
);
2574 /* Every plt entry requires a JMP_SLOT relocation. */
2575 spltrel
= elf_hash_table(info
)->srelplt
;
2579 if (elf64_alpha_use_secureplt
)
2580 entries
= (splt
->size
- NEW_PLT_HEADER_SIZE
) / NEW_PLT_ENTRY_SIZE
;
2582 entries
= (splt
->size
- OLD_PLT_HEADER_SIZE
) / OLD_PLT_ENTRY_SIZE
;
2584 spltrel
->size
= entries
* sizeof (Elf64_External_Rela
);
2586 /* When using the secureplt, we need two words somewhere in the data
2587 segment for the dynamic linker to tell us where to go. This is the
2588 entire contents of the .got.plt section. */
2589 if (elf64_alpha_use_secureplt
)
2591 sgotplt
= elf_hash_table(info
)->sgotplt
;
2592 sgotplt
->size
= entries
? 16 : 0;
2597 elf64_alpha_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2598 struct bfd_link_info
*info
)
2601 struct alpha_elf_link_hash_table
* htab
;
2603 if (bfd_link_relocatable (info
))
2606 htab
= alpha_elf_hash_table (info
);
2610 if (!elf64_alpha_size_got_sections (info
, TRUE
))
2613 /* Allocate space for all of the .got subsections. */
2615 for ( ; i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2617 asection
*s
= alpha_elf_tdata(i
)->got
;
2620 s
->contents
= (bfd_byte
*) bfd_zalloc (i
, s
->size
);
2621 if (s
->contents
== NULL
)
2629 /* The number of dynamic relocations required by a static relocation. */
2632 alpha_dynamic_entries_for_reloc (int r_type
, int dynamic
, int shared
, int pie
)
2636 /* May appear in GOT entries. */
2638 return (dynamic
? 2 : shared
? 1 : 0);
2639 case R_ALPHA_TLSLDM
:
2641 case R_ALPHA_LITERAL
:
2642 return dynamic
|| shared
;
2643 case R_ALPHA_GOTTPREL
:
2644 return dynamic
|| (shared
&& !pie
);
2645 case R_ALPHA_GOTDTPREL
:
2648 /* May appear in data sections. */
2649 case R_ALPHA_REFLONG
:
2650 case R_ALPHA_REFQUAD
:
2651 return dynamic
|| shared
;
2652 case R_ALPHA_TPREL64
:
2653 return dynamic
|| (shared
&& !pie
);
2655 /* Everything else is illegal. We'll issue an error during
2656 relocate_section. */
2662 /* Work out the sizes of the dynamic relocation entries. */
2665 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry
*h
,
2666 struct bfd_link_info
*info
)
2668 bfd_boolean dynamic
;
2669 struct alpha_elf_reloc_entry
*relent
;
2670 unsigned long entries
;
2672 /* If the symbol was defined as a common symbol in a regular object
2673 file, and there was no definition in any dynamic object, then the
2674 linker will have allocated space for the symbol in a common
2675 section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2676 set. This is done for dynamic symbols in
2677 elf_adjust_dynamic_symbol but this is not done for non-dynamic
2678 symbols, somehow. */
2679 if (!h
->root
.def_regular
2680 && h
->root
.ref_regular
2681 && !h
->root
.def_dynamic
2682 && (h
->root
.root
.type
== bfd_link_hash_defined
2683 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2684 && !(h
->root
.root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2685 h
->root
.def_regular
= 1;
2687 /* If the symbol is dynamic, we'll need all the relocations in their
2688 natural form. If this is a shared object, and it has been forced
2689 local, we'll need the same number of RELATIVE relocations. */
2690 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
2692 /* If the symbol is a hidden undefined weak, then we never have any
2693 relocations. Avoid the loop which may want to add RELATIVE relocs
2694 based on bfd_link_pic (info). */
2695 if (h
->root
.root
.type
== bfd_link_hash_undefweak
&& !dynamic
)
2698 for (relent
= h
->reloc_entries
; relent
; relent
= relent
->next
)
2700 entries
= alpha_dynamic_entries_for_reloc (relent
->rtype
, dynamic
,
2701 bfd_link_pic (info
),
2702 bfd_link_pie (info
));
2705 relent
->srel
->size
+=
2706 entries
* sizeof (Elf64_External_Rela
) * relent
->count
;
2707 if (relent
->reltext
)
2708 info
->flags
|= DT_TEXTREL
;
2715 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2719 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry
*h
,
2720 struct bfd_link_info
*info
)
2722 bfd_boolean dynamic
;
2723 struct alpha_elf_got_entry
*gotent
;
2724 unsigned long entries
;
2726 /* If we're using a plt for this symbol, then all of its relocations
2727 for its got entries go into .rela.plt. */
2728 if (h
->root
.needs_plt
)
2731 /* If the symbol is dynamic, we'll need all the relocations in their
2732 natural form. If this is a shared object, and it has been forced
2733 local, we'll need the same number of RELATIVE relocations. */
2734 dynamic
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
2736 /* If the symbol is a hidden undefined weak, then we never have any
2737 relocations. Avoid the loop which may want to add RELATIVE relocs
2738 based on bfd_link_pic (info). */
2739 if (h
->root
.root
.type
== bfd_link_hash_undefweak
&& !dynamic
)
2743 for (gotent
= h
->got_entries
; gotent
; gotent
= gotent
->next
)
2744 if (gotent
->use_count
> 0)
2745 entries
+= alpha_dynamic_entries_for_reloc (gotent
->reloc_type
, dynamic
,
2746 bfd_link_pic (info
),
2747 bfd_link_pie (info
));
2751 asection
*srel
= elf_hash_table(info
)->srelgot
;
2752 BFD_ASSERT (srel
!= NULL
);
2753 srel
->size
+= sizeof (Elf64_External_Rela
) * entries
;
2759 /* Set the sizes of the dynamic relocation sections. */
2762 elf64_alpha_size_rela_got_section (struct bfd_link_info
*info
)
2764 unsigned long entries
;
2767 struct alpha_elf_link_hash_table
* htab
;
2769 htab
= alpha_elf_hash_table (info
);
2773 /* Shared libraries often require RELATIVE relocs, and some relocs
2774 require attention for the main application as well. */
2777 for (i
= htab
->got_list
;
2778 i
; i
= alpha_elf_tdata(i
)->got_link_next
)
2782 for (j
= i
; j
; j
= alpha_elf_tdata(j
)->in_got_link_next
)
2784 struct alpha_elf_got_entry
**local_got_entries
, *gotent
;
2787 local_got_entries
= alpha_elf_tdata(j
)->local_got_entries
;
2788 if (!local_got_entries
)
2791 for (k
= 0, n
= elf_tdata(j
)->symtab_hdr
.sh_info
; k
< n
; ++k
)
2792 for (gotent
= local_got_entries
[k
];
2793 gotent
; gotent
= gotent
->next
)
2794 if (gotent
->use_count
> 0)
2795 entries
+= (alpha_dynamic_entries_for_reloc
2796 (gotent
->reloc_type
, 0, bfd_link_pic (info
),
2797 bfd_link_pie (info
)));
2801 srel
= elf_hash_table(info
)->srelgot
;
2804 BFD_ASSERT (entries
== 0);
2807 srel
->size
= sizeof (Elf64_External_Rela
) * entries
;
2809 /* Now do the non-local symbols. */
2810 alpha_elf_link_hash_traverse (htab
,
2811 elf64_alpha_size_rela_got_1
, info
);
2814 /* Set the sizes of the dynamic sections. */
2817 elf64_alpha_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2818 struct bfd_link_info
*info
)
2822 bfd_boolean relplt
, relocs
;
2823 struct alpha_elf_link_hash_table
* htab
;
2825 htab
= alpha_elf_hash_table (info
);
2829 dynobj
= elf_hash_table(info
)->dynobj
;
2830 BFD_ASSERT(dynobj
!= NULL
);
2832 if (elf_hash_table (info
)->dynamic_sections_created
)
2834 /* Set the contents of the .interp section to the interpreter. */
2835 if (bfd_link_executable (info
) && !info
->nointerp
)
2837 s
= bfd_get_linker_section (dynobj
, ".interp");
2838 BFD_ASSERT (s
!= NULL
);
2839 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2840 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2843 /* Now that we've seen all of the input files, we can decide which
2844 symbols need dynamic relocation entries and which don't. We've
2845 collected information in check_relocs that we can now apply to
2846 size the dynamic relocation sections. */
2847 alpha_elf_link_hash_traverse (htab
,
2848 elf64_alpha_calc_dynrel_sizes
, info
);
2850 elf64_alpha_size_rela_got_section (info
);
2851 elf64_alpha_size_plt_section (info
);
2853 /* else we're not dynamic and by definition we don't need such things. */
2855 /* The check_relocs and adjust_dynamic_symbol entry points have
2856 determined the sizes of the various dynamic sections. Allocate
2860 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2864 if (!(s
->flags
& SEC_LINKER_CREATED
))
2867 /* It's OK to base decisions on the section name, because none
2868 of the dynobj section names depend upon the input files. */
2869 name
= bfd_section_name (s
);
2871 if (CONST_STRNEQ (name
, ".rela"))
2875 if (strcmp (name
, ".rela.plt") == 0)
2880 /* We use the reloc_count field as a counter if we need
2881 to copy relocs into the output file. */
2885 else if (! CONST_STRNEQ (name
, ".got")
2886 && strcmp (name
, ".plt") != 0
2887 && strcmp (name
, ".dynbss") != 0)
2889 /* It's not one of our dynamic sections, so don't allocate space. */
2895 /* If we don't need this section, strip it from the output file.
2896 This is to handle .rela.bss and .rela.plt. We must create it
2897 in create_dynamic_sections, because it must be created before
2898 the linker maps input sections to output sections. The
2899 linker does that before adjust_dynamic_symbol is called, and
2900 it is that function which decides whether anything needs to
2901 go into these sections. */
2902 if (!CONST_STRNEQ (name
, ".got"))
2903 s
->flags
|= SEC_EXCLUDE
;
2905 else if ((s
->flags
& SEC_HAS_CONTENTS
) != 0)
2907 /* Allocate memory for the section contents. */
2908 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2909 if (s
->contents
== NULL
)
2914 if (elf_hash_table (info
)->dynamic_sections_created
)
2916 /* Add some entries to the .dynamic section. We fill in the
2917 values later, in elf64_alpha_finish_dynamic_sections, but we
2918 must add the entries now so that we get the correct size for
2919 the .dynamic section. The DT_DEBUG entry is filled in by the
2920 dynamic linker and used by the debugger. */
2921 #define add_dynamic_entry(TAG, VAL) \
2922 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2924 if (bfd_link_executable (info
))
2926 if (!add_dynamic_entry (DT_DEBUG
, 0))
2932 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2933 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2934 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2935 || !add_dynamic_entry (DT_JMPREL
, 0))
2938 if (elf64_alpha_use_secureplt
2939 && !add_dynamic_entry (DT_ALPHA_PLTRO
, 1))
2945 if (!add_dynamic_entry (DT_RELA
, 0)
2946 || !add_dynamic_entry (DT_RELASZ
, 0)
2947 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
2950 if (info
->flags
& DF_TEXTREL
)
2952 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2957 #undef add_dynamic_entry
2962 /* These functions do relaxation for Alpha ELF.
2964 Currently I'm only handling what I can do with existing compiler
2965 and assembler support, which means no instructions are removed,
2966 though some may be nopped. At this time GCC does not emit enough
2967 information to do all of the relaxing that is possible. It will
2968 take some not small amount of work for that to happen.
2970 There are a couple of interesting papers that I once read on this
2971 subject, that I cannot find references to at the moment, that
2972 related to Alpha in particular. They are by David Wall, then of
2975 struct alpha_relax_info
2980 Elf_Internal_Shdr
*symtab_hdr
;
2981 Elf_Internal_Rela
*relocs
, *relend
;
2982 struct bfd_link_info
*link_info
;
2986 struct alpha_elf_link_hash_entry
*h
;
2987 struct alpha_elf_got_entry
**first_gotent
;
2988 struct alpha_elf_got_entry
*gotent
;
2989 bfd_boolean changed_contents
;
2990 bfd_boolean changed_relocs
;
2991 unsigned char other
;
2994 static Elf_Internal_Rela
*
2995 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela
*rel
,
2996 Elf_Internal_Rela
*relend
,
2997 bfd_vma offset
, int type
)
2999 while (rel
< relend
)
3001 if (rel
->r_offset
== offset
3002 && ELF64_R_TYPE (rel
->r_info
) == (unsigned int) type
)
3010 elf64_alpha_relax_got_load (struct alpha_relax_info
*info
, bfd_vma symval
,
3011 Elf_Internal_Rela
*irel
, unsigned long r_type
)
3014 bfd_signed_vma disp
;
3016 /* Get the instruction. */
3017 insn
= bfd_get_32 (info
->abfd
, info
->contents
+ irel
->r_offset
);
3019 if (insn
>> 26 != OP_LDQ
)
3021 reloc_howto_type
*howto
= elf64_alpha_howto_table
+ r_type
;
3023 /* xgettext:c-format */
3024 (_("%pB: %pA+%#" PRIx64
": warning: "
3025 "%s relocation against unexpected insn"),
3026 info
->abfd
, info
->sec
, (uint64_t) irel
->r_offset
, howto
->name
);
3030 /* Can't relax dynamic symbols. */
3031 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
3034 /* Can't use local-exec relocations in shared libraries. */
3035 if (r_type
== R_ALPHA_GOTTPREL
3036 && bfd_link_dll (info
->link_info
))
3039 if (r_type
== R_ALPHA_LITERAL
)
3041 /* Look for nice constant addresses. This includes the not-uncommon
3042 special case of 0 for undefweak symbols. */
3043 if ((info
->h
&& info
->h
->root
.root
.type
== bfd_link_hash_undefweak
)
3044 || (!bfd_link_pic (info
->link_info
)
3045 && (symval
>= (bfd_vma
)-0x8000 || symval
< 0x8000)))
3048 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
3049 insn
|= (symval
& 0xffff);
3050 r_type
= R_ALPHA_NONE
;
3054 /* We may only create GPREL relocs during the second pass. */
3055 if (info
->link_info
->relax_pass
== 0)
3058 disp
= symval
- info
->gp
;
3059 insn
= (OP_LDA
<< 26) | (insn
& 0x03ff0000);
3060 r_type
= R_ALPHA_GPREL16
;
3065 bfd_vma dtp_base
, tp_base
;
3067 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
3068 dtp_base
= alpha_get_dtprel_base (info
->link_info
);
3069 tp_base
= alpha_get_tprel_base (info
->link_info
);
3070 disp
= symval
- (r_type
== R_ALPHA_GOTDTPREL
? dtp_base
: tp_base
);
3072 insn
= (OP_LDA
<< 26) | (insn
& (31 << 21)) | (31 << 16);
3076 case R_ALPHA_GOTDTPREL
:
3077 r_type
= R_ALPHA_DTPREL16
;
3079 case R_ALPHA_GOTTPREL
:
3080 r_type
= R_ALPHA_TPREL16
;
3088 if (disp
< -0x8000 || disp
>= 0x8000)
3091 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, info
->contents
+ irel
->r_offset
);
3092 info
->changed_contents
= TRUE
;
3094 /* Reduce the use count on this got entry by one, possibly
3096 if (--info
->gotent
->use_count
== 0)
3098 int sz
= alpha_got_entry_size (r_type
);
3099 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3101 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
3104 /* Smash the existing GOT relocation for its 16-bit immediate pair. */
3105 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
), r_type
);
3106 info
->changed_relocs
= TRUE
;
3108 /* ??? Search forward through this basic block looking for insns
3109 that use the target register. Stop after an insn modifying the
3110 register is seen, or after a branch or call.
3112 Any such memory load insn may be substituted by a load directly
3113 off the GP. This allows the memory load insn to be issued before
3114 the calculated GP register would otherwise be ready.
3116 Any such jsr insn can be replaced by a bsr if it is in range.
3118 This would mean that we'd have to _add_ relocations, the pain of
3119 which gives one pause. */
3125 elf64_alpha_relax_opt_call (struct alpha_relax_info
*info
, bfd_vma symval
)
3127 /* If the function has the same gp, and we can identify that the
3128 function does not use its function pointer, we can eliminate the
3131 /* If the symbol is marked NOPV, we are being told the function never
3132 needs its procedure value. */
3133 if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_NOPV
)
3136 /* If the symbol is marked STD_GP, we are being told the function does
3137 a normal ldgp in the first two words. */
3138 else if ((info
->other
& STO_ALPHA_STD_GPLOAD
) == STO_ALPHA_STD_GPLOAD
)
3141 /* Otherwise, we may be able to identify a GP load in the first two
3142 words, which we can then skip. */
3145 Elf_Internal_Rela
*tsec_relocs
, *tsec_relend
, *tsec_free
, *gpdisp
;
3148 /* Load the relocations from the section that the target symbol is in. */
3149 if (info
->sec
== info
->tsec
)
3151 tsec_relocs
= info
->relocs
;
3152 tsec_relend
= info
->relend
;
3157 tsec_relocs
= (_bfd_elf_link_read_relocs
3158 (info
->abfd
, info
->tsec
, NULL
,
3159 (Elf_Internal_Rela
*) NULL
,
3160 info
->link_info
->keep_memory
));
3161 if (tsec_relocs
== NULL
)
3163 tsec_relend
= tsec_relocs
+ info
->tsec
->reloc_count
;
3164 tsec_free
= (elf_section_data (info
->tsec
)->relocs
== tsec_relocs
3169 /* Recover the symbol's offset within the section. */
3170 ofs
= (symval
- info
->tsec
->output_section
->vma
3171 - info
->tsec
->output_offset
);
3173 /* Look for a GPDISP reloc. */
3174 gpdisp
= (elf64_alpha_find_reloc_at_ofs
3175 (tsec_relocs
, tsec_relend
, ofs
, R_ALPHA_GPDISP
));
3177 if (!gpdisp
|| gpdisp
->r_addend
!= 4)
3187 /* We've now determined that we can skip an initial gp load. Verify
3188 that the call and the target use the same gp. */
3189 if (info
->link_info
->output_bfd
->xvec
!= info
->tsec
->owner
->xvec
3190 || info
->gotobj
!= alpha_elf_tdata (info
->tsec
->owner
)->gotobj
)
3197 elf64_alpha_relax_with_lituse (struct alpha_relax_info
*info
,
3198 bfd_vma symval
, Elf_Internal_Rela
*irel
)
3200 Elf_Internal_Rela
*urel
, *erel
, *irelend
= info
->relend
;
3202 bfd_signed_vma disp
;
3205 bfd_boolean lit_reused
= FALSE
;
3206 bfd_boolean all_optimized
= TRUE
;
3207 bfd_boolean changed_contents
;
3208 bfd_boolean changed_relocs
;
3209 bfd_byte
*contents
= info
->contents
;
3210 bfd
*abfd
= info
->abfd
;
3211 bfd_vma sec_output_vma
;
3212 unsigned int lit_insn
;
3215 lit_insn
= bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
3216 if (lit_insn
>> 26 != OP_LDQ
)
3219 /* xgettext:c-format */
3220 (_("%pB: %pA+%#" PRIx64
": warning: "
3221 "%s relocation against unexpected insn"),
3222 abfd
, info
->sec
, (uint64_t) irel
->r_offset
, "LITERAL");
3226 /* Can't relax dynamic symbols. */
3227 if (alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
))
3230 changed_contents
= info
->changed_contents
;
3231 changed_relocs
= info
->changed_relocs
;
3232 sec_output_vma
= info
->sec
->output_section
->vma
+ info
->sec
->output_offset
;
3233 relax_pass
= info
->link_info
->relax_pass
;
3235 /* Summarize how this particular LITERAL is used. */
3236 for (erel
= irel
+1, flags
= 0; erel
< irelend
; ++erel
)
3238 if (ELF64_R_TYPE (erel
->r_info
) != R_ALPHA_LITUSE
)
3240 if (erel
->r_addend
<= 6)
3241 flags
|= 1 << erel
->r_addend
;
3244 /* A little preparation for the loop... */
3245 disp
= symval
- info
->gp
;
3247 for (urel
= irel
+1; urel
< erel
; ++urel
)
3249 bfd_vma urel_r_offset
= urel
->r_offset
;
3252 bfd_signed_vma xdisp
;
3253 Elf_Internal_Rela nrel
;
3255 insn
= bfd_get_32 (abfd
, contents
+ urel_r_offset
);
3257 switch (urel
->r_addend
)
3259 case LITUSE_ALPHA_ADDR
:
3261 /* This type is really just a placeholder to note that all
3262 uses cannot be optimized, but to still allow some. */
3263 all_optimized
= FALSE
;
3266 case LITUSE_ALPHA_BASE
:
3267 /* We may only create GPREL relocs during the second pass. */
3268 if (relax_pass
== 0)
3270 all_optimized
= FALSE
;
3274 /* We can always optimize 16-bit displacements. */
3276 /* Extract the displacement from the instruction, sign-extending
3277 it if necessary, then test whether it is within 16 or 32 bits
3278 displacement from GP. */
3279 insn_disp
= ((insn
& 0xffff) ^ 0x8000) - 0x8000;
3281 xdisp
= disp
+ insn_disp
;
3282 fits16
= (xdisp
>= - (bfd_signed_vma
) 0x8000 && xdisp
< 0x8000);
3283 fits32
= (xdisp
>= - (bfd_signed_vma
) 0x80000000
3284 && xdisp
< 0x7fff8000);
3288 /* Take the op code and dest from this insn, take the base
3289 register from the literal insn. Leave the offset alone. */
3290 insn
= (insn
& 0xffe0ffff) | (lit_insn
& 0x001f0000);
3291 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3292 changed_contents
= TRUE
;
3295 nrel
.r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3297 nrel
.r_addend
= irel
->r_addend
;
3299 /* As we adjust, move the reloc to the end so that we don't
3300 break the LITERAL+LITUSE chain. */
3304 changed_relocs
= TRUE
;
3307 /* If all mem+byte, we can optimize 32-bit mem displacements. */
3308 else if (fits32
&& !(flags
& ~6))
3310 /* FIXME: sanity check that lit insn Ra is mem insn Rb. */
3312 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3314 lit_insn
= (OP_LDAH
<< 26) | (lit_insn
& 0x03ff0000);
3315 bfd_put_32 (abfd
, (bfd_vma
) lit_insn
, contents
+ irel
->r_offset
);
3317 changed_contents
= TRUE
;
3319 /* Since all relocs must be optimized, don't bother swapping
3320 this relocation to the end. */
3321 urel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3323 urel
->r_addend
= irel
->r_addend
;
3324 changed_relocs
= TRUE
;
3327 all_optimized
= FALSE
;
3330 case LITUSE_ALPHA_BYTOFF
:
3331 /* We can always optimize byte instructions. */
3333 /* FIXME: sanity check the insn for byte op. Check that the
3334 literal dest reg is indeed Rb in the byte insn. */
3336 insn
&= ~ (unsigned) 0x001ff000;
3337 insn
|= ((symval
& 7) << 13) | 0x1000;
3338 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3339 changed_contents
= TRUE
;
3342 nrel
.r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3345 /* As we adjust, move the reloc to the end so that we don't
3346 break the LITERAL+LITUSE chain. */
3350 changed_relocs
= TRUE
;
3353 case LITUSE_ALPHA_JSR
:
3354 case LITUSE_ALPHA_TLSGD
:
3355 case LITUSE_ALPHA_TLSLDM
:
3356 case LITUSE_ALPHA_JSRDIRECT
:
3358 bfd_vma optdest
, org
;
3359 bfd_signed_vma odisp
;
3361 /* For undefined weak symbols, we're mostly interested in getting
3362 rid of the got entry whenever possible, so optimize this to a
3363 use of the zero register. */
3364 if (info
->h
&& info
->h
->root
.root
.type
== bfd_link_hash_undefweak
)
3367 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3369 changed_contents
= TRUE
;
3373 /* If not zero, place to jump without needing pv. */
3374 optdest
= elf64_alpha_relax_opt_call (info
, symval
);
3375 org
= sec_output_vma
+ urel_r_offset
+ 4;
3376 odisp
= (optdest
? optdest
: symval
) - org
;
3378 if (odisp
>= -0x400000 && odisp
< 0x400000)
3380 Elf_Internal_Rela
*xrel
;
3382 /* Preserve branch prediction call stack when possible. */
3383 if ((insn
& INSN_JSR_MASK
) == INSN_JSR
)
3384 insn
= (OP_BSR
<< 26) | (insn
& 0x03e00000);
3386 insn
= (OP_BR
<< 26) | (insn
& 0x03e00000);
3387 bfd_put_32 (abfd
, (bfd_vma
) insn
, contents
+ urel_r_offset
);
3388 changed_contents
= TRUE
;
3391 nrel
.r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
3393 nrel
.r_addend
= irel
->r_addend
;
3396 nrel
.r_addend
+= optdest
- symval
;
3398 all_optimized
= FALSE
;
3400 /* Kill any HINT reloc that might exist for this insn. */
3401 xrel
= (elf64_alpha_find_reloc_at_ofs
3402 (info
->relocs
, info
->relend
, urel_r_offset
,
3405 xrel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3407 /* As we adjust, move the reloc to the end so that we don't
3408 break the LITERAL+LITUSE chain. */
3413 info
->changed_relocs
= TRUE
;
3416 all_optimized
= FALSE
;
3418 /* Even if the target is not in range for a direct branch,
3419 if we share a GP, we can eliminate the gp reload. */
3422 Elf_Internal_Rela
*gpdisp
3423 = (elf64_alpha_find_reloc_at_ofs
3424 (info
->relocs
, irelend
, urel_r_offset
+ 4,
3428 bfd_byte
*p_ldah
= contents
+ gpdisp
->r_offset
;
3429 bfd_byte
*p_lda
= p_ldah
+ gpdisp
->r_addend
;
3430 unsigned int ldah
= bfd_get_32 (abfd
, p_ldah
);
3431 unsigned int lda
= bfd_get_32 (abfd
, p_lda
);
3433 /* Verify that the instruction is "ldah $29,0($26)".
3434 Consider a function that ends in a noreturn call,
3435 and that the next function begins with an ldgp,
3436 and that by accident there is no padding between.
3437 In that case the insn would use $27 as the base. */
3438 if (ldah
== 0x27ba0000 && lda
== 0x23bd0000)
3440 bfd_put_32 (abfd
, (bfd_vma
) INSN_UNOP
, p_ldah
);
3441 bfd_put_32 (abfd
, (bfd_vma
) INSN_UNOP
, p_lda
);
3443 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3444 changed_contents
= TRUE
;
3445 changed_relocs
= TRUE
;
3454 /* If we reused the literal instruction, we must have optimized all. */
3455 BFD_ASSERT(!lit_reused
|| all_optimized
);
3457 /* If all cases were optimized, we can reduce the use count on this
3458 got entry by one, possibly eliminating it. */
3461 if (--info
->gotent
->use_count
== 0)
3463 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
3464 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3466 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
3469 /* If the literal instruction is no longer needed (it may have been
3470 reused. We can eliminate it. */
3471 /* ??? For now, I don't want to deal with compacting the section,
3472 so just nop it out. */
3475 irel
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3476 changed_relocs
= TRUE
;
3478 bfd_put_32 (abfd
, (bfd_vma
) INSN_UNOP
, contents
+ irel
->r_offset
);
3479 changed_contents
= TRUE
;
3483 info
->changed_contents
= changed_contents
;
3484 info
->changed_relocs
= changed_relocs
;
3486 if (all_optimized
|| relax_pass
== 0)
3488 return elf64_alpha_relax_got_load (info
, symval
, irel
, R_ALPHA_LITERAL
);
3492 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info
*info
, bfd_vma symval
,
3493 Elf_Internal_Rela
*irel
, bfd_boolean is_gd
)
3496 unsigned int insn
, tlsgd_reg
;
3497 Elf_Internal_Rela
*gpdisp
, *hint
;
3498 bfd_boolean dynamic
, use_gottprel
;
3499 unsigned long new_symndx
;
3501 dynamic
= alpha_elf_dynamic_symbol_p (&info
->h
->root
, info
->link_info
);
3503 /* If a TLS symbol is accessed using IE at least once, there is no point
3504 to use dynamic model for it. */
3505 if (is_gd
&& info
->h
&& (info
->h
->flags
& ALPHA_ELF_LINK_HASH_TLS_IE
))
3508 /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3509 then we might as well relax to IE. */
3510 else if (bfd_link_pic (info
->link_info
) && !dynamic
3511 && (info
->link_info
->flags
& DF_STATIC_TLS
))
3514 /* Otherwise we must be building an executable to do anything. */
3515 else if (bfd_link_pic (info
->link_info
))
3518 /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3519 the matching LITUSE_TLS relocations. */
3520 if (irel
+ 2 >= info
->relend
)
3522 if (ELF64_R_TYPE (irel
[1].r_info
) != R_ALPHA_LITERAL
3523 || ELF64_R_TYPE (irel
[2].r_info
) != R_ALPHA_LITUSE
3524 || irel
[2].r_addend
!= (is_gd
? LITUSE_ALPHA_TLSGD
: LITUSE_ALPHA_TLSLDM
))
3527 /* There must be a GPDISP relocation positioned immediately after the
3528 LITUSE relocation. */
3529 gpdisp
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
3530 irel
[2].r_offset
+ 4, R_ALPHA_GPDISP
);
3534 pos
[0] = info
->contents
+ irel
[0].r_offset
;
3535 pos
[1] = info
->contents
+ irel
[1].r_offset
;
3536 pos
[2] = info
->contents
+ irel
[2].r_offset
;
3537 pos
[3] = info
->contents
+ gpdisp
->r_offset
;
3538 pos
[4] = pos
[3] + gpdisp
->r_addend
;
3540 /* Beware of the compiler hoisting part of the sequence out a loop
3541 and adjusting the destination register for the TLSGD insn. If this
3542 happens, there will be a move into $16 before the JSR insn, so only
3543 transformations of the first insn pair should use this register. */
3544 tlsgd_reg
= bfd_get_32 (info
->abfd
, pos
[0]);
3545 tlsgd_reg
= (tlsgd_reg
>> 21) & 31;
3547 /* Generally, the positions are not allowed to be out of order, lest the
3548 modified insn sequence have different register lifetimes. We can make
3549 an exception when pos 1 is adjacent to pos 0. */
3550 if (pos
[1] + 4 == pos
[0])
3552 bfd_byte
*tmp
= pos
[0];
3556 if (pos
[1] >= pos
[2] || pos
[2] >= pos
[3])
3559 /* Reduce the use count on the LITERAL relocation. Do this before we
3560 smash the symndx when we adjust the relocations below. */
3562 struct alpha_elf_got_entry
*lit_gotent
;
3563 struct alpha_elf_link_hash_entry
*lit_h
;
3566 BFD_ASSERT (ELF64_R_SYM (irel
[1].r_info
) >= info
->symtab_hdr
->sh_info
);
3567 indx
= ELF64_R_SYM (irel
[1].r_info
) - info
->symtab_hdr
->sh_info
;
3568 lit_h
= alpha_elf_sym_hashes (info
->abfd
)[indx
];
3570 while (lit_h
->root
.root
.type
== bfd_link_hash_indirect
3571 || lit_h
->root
.root
.type
== bfd_link_hash_warning
)
3572 lit_h
= (struct alpha_elf_link_hash_entry
*) lit_h
->root
.root
.u
.i
.link
;
3574 for (lit_gotent
= lit_h
->got_entries
; lit_gotent
;
3575 lit_gotent
= lit_gotent
->next
)
3576 if (lit_gotent
->gotobj
== info
->gotobj
3577 && lit_gotent
->reloc_type
== R_ALPHA_LITERAL
3578 && lit_gotent
->addend
== irel
[1].r_addend
)
3580 BFD_ASSERT (lit_gotent
);
3582 if (--lit_gotent
->use_count
== 0)
3584 int sz
= alpha_got_entry_size (R_ALPHA_LITERAL
);
3585 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3591 lda $16,x($gp) !tlsgd!1
3592 ldq $27,__tls_get_addr($gp) !literal!1
3593 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3594 ldah $29,0($26) !gpdisp!2
3595 lda $29,0($29) !gpdisp!2
3597 ldq $16,x($gp) !gottprel
3602 or the first pair to
3603 lda $16,x($gp) !tprel
3606 ldah $16,x($gp) !tprelhi
3607 lda $16,x($16) !tprello
3611 use_gottprel
= FALSE
;
3612 new_symndx
= is_gd
? ELF64_R_SYM (irel
->r_info
) : STN_UNDEF
;
3614 /* Some compilers warn about a Boolean-looking expression being
3615 used in a switch. The explicit cast silences them. */
3616 switch ((int) (!dynamic
&& !bfd_link_pic (info
->link_info
)))
3621 bfd_signed_vma disp
;
3623 BFD_ASSERT (elf_hash_table (info
->link_info
)->tls_sec
!= NULL
);
3624 tp_base
= alpha_get_tprel_base (info
->link_info
);
3625 disp
= symval
- tp_base
;
3627 if (disp
>= -0x8000 && disp
< 0x8000)
3629 insn
= (OP_LDA
<< 26) | (tlsgd_reg
<< 21) | (31 << 16);
3630 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
3631 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
3633 irel
[0].r_offset
= pos
[0] - info
->contents
;
3634 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPREL16
);
3635 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3638 else if (disp
>= -(bfd_signed_vma
) 0x80000000
3639 && disp
< (bfd_signed_vma
) 0x7fff8000
3640 && pos
[0] + 4 == pos
[1])
3642 insn
= (OP_LDAH
<< 26) | (tlsgd_reg
<< 21) | (31 << 16);
3643 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
3644 insn
= (OP_LDA
<< 26) | (tlsgd_reg
<< 21) | (tlsgd_reg
<< 16);
3645 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[1]);
3647 irel
[0].r_offset
= pos
[0] - info
->contents
;
3648 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELHI
);
3649 irel
[1].r_offset
= pos
[1] - info
->contents
;
3650 irel
[1].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_TPRELLO
);
3657 use_gottprel
= TRUE
;
3659 insn
= (OP_LDQ
<< 26) | (tlsgd_reg
<< 21) | (29 << 16);
3660 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[0]);
3661 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[1]);
3663 irel
[0].r_offset
= pos
[0] - info
->contents
;
3664 irel
[0].r_info
= ELF64_R_INFO (new_symndx
, R_ALPHA_GOTTPREL
);
3665 irel
[1].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3669 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_RDUNIQ
, pos
[2]);
3671 insn
= INSN_ADDQ
| (16 << 21) | (0 << 16) | (0 << 0);
3672 bfd_put_32 (info
->abfd
, (bfd_vma
) insn
, pos
[3]);
3674 bfd_put_32 (info
->abfd
, (bfd_vma
) INSN_UNOP
, pos
[4]);
3676 irel
[2].r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3677 gpdisp
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3679 hint
= elf64_alpha_find_reloc_at_ofs (info
->relocs
, info
->relend
,
3680 irel
[2].r_offset
, R_ALPHA_HINT
);
3682 hint
->r_info
= ELF64_R_INFO (0, R_ALPHA_NONE
);
3684 info
->changed_contents
= TRUE
;
3685 info
->changed_relocs
= TRUE
;
3687 /* Reduce the use count on the TLSGD/TLSLDM relocation. */
3688 if (--info
->gotent
->use_count
== 0)
3690 int sz
= alpha_got_entry_size (info
->gotent
->reloc_type
);
3691 alpha_elf_tdata (info
->gotobj
)->total_got_size
-= sz
;
3693 alpha_elf_tdata (info
->gotobj
)->local_got_size
-= sz
;
3696 /* If we've switched to a GOTTPREL relocation, increment the reference
3697 count on that got entry. */
3700 struct alpha_elf_got_entry
*tprel_gotent
;
3702 for (tprel_gotent
= *info
->first_gotent
; tprel_gotent
;
3703 tprel_gotent
= tprel_gotent
->next
)
3704 if (tprel_gotent
->gotobj
== info
->gotobj
3705 && tprel_gotent
->reloc_type
== R_ALPHA_GOTTPREL
3706 && tprel_gotent
->addend
== irel
->r_addend
)
3709 tprel_gotent
->use_count
++;
3712 if (info
->gotent
->use_count
== 0)
3713 tprel_gotent
= info
->gotent
;
3716 tprel_gotent
= (struct alpha_elf_got_entry
*)
3717 bfd_alloc (info
->abfd
, sizeof (struct alpha_elf_got_entry
));
3721 tprel_gotent
->next
= *info
->first_gotent
;
3722 *info
->first_gotent
= tprel_gotent
;
3724 tprel_gotent
->gotobj
= info
->gotobj
;
3725 tprel_gotent
->addend
= irel
->r_addend
;
3726 tprel_gotent
->got_offset
= -1;
3727 tprel_gotent
->reloc_done
= 0;
3728 tprel_gotent
->reloc_xlated
= 0;
3731 tprel_gotent
->use_count
= 1;
3732 tprel_gotent
->reloc_type
= R_ALPHA_GOTTPREL
;
3740 elf64_alpha_relax_section (bfd
*abfd
, asection
*sec
,
3741 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
3743 Elf_Internal_Shdr
*symtab_hdr
;
3744 Elf_Internal_Rela
*internal_relocs
;
3745 Elf_Internal_Rela
*irel
, *irelend
;
3746 Elf_Internal_Sym
*isymbuf
= NULL
;
3747 struct alpha_elf_got_entry
**local_got_entries
;
3748 struct alpha_relax_info info
;
3749 struct alpha_elf_link_hash_table
* htab
;
3752 htab
= alpha_elf_hash_table (link_info
);
3756 /* There's nothing to change, yet. */
3759 if (bfd_link_relocatable (link_info
)
3760 || ((sec
->flags
& (SEC_CODE
| SEC_RELOC
| SEC_ALLOC
))
3761 != (SEC_CODE
| SEC_RELOC
| SEC_ALLOC
))
3762 || sec
->reloc_count
== 0)
3765 BFD_ASSERT (is_alpha_elf (abfd
));
3766 relax_pass
= link_info
->relax_pass
;
3768 /* Make sure our GOT and PLT tables are up-to-date. */
3769 if (htab
->relax_trip
!= link_info
->relax_trip
)
3771 htab
->relax_trip
= link_info
->relax_trip
;
3773 /* This should never fail after the initial round, since the only error
3774 is GOT overflow, and relaxation only shrinks the table. However, we
3775 may only merge got sections during the first pass. If we merge
3776 sections after we've created GPREL relocs, the GP for the merged
3777 section backs up which may put the relocs out of range. */
3778 if (!elf64_alpha_size_got_sections (link_info
, relax_pass
== 0))
3780 if (elf_hash_table (link_info
)->dynamic_sections_created
)
3782 elf64_alpha_size_plt_section (link_info
);
3783 elf64_alpha_size_rela_got_section (link_info
);
3787 symtab_hdr
= &elf_symtab_hdr (abfd
);
3788 local_got_entries
= alpha_elf_tdata(abfd
)->local_got_entries
;
3790 /* Load the relocations for this section. */
3791 internal_relocs
= (_bfd_elf_link_read_relocs
3792 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
3793 link_info
->keep_memory
));
3794 if (internal_relocs
== NULL
)
3797 memset(&info
, 0, sizeof (info
));
3800 info
.link_info
= link_info
;
3801 info
.symtab_hdr
= symtab_hdr
;
3802 info
.relocs
= internal_relocs
;
3803 info
.relend
= irelend
= internal_relocs
+ sec
->reloc_count
;
3805 /* Find the GP for this object. Do not store the result back via
3806 _bfd_set_gp_value, since this could change again before final. */
3807 info
.gotobj
= alpha_elf_tdata (abfd
)->gotobj
;
3810 asection
*sgot
= alpha_elf_tdata (info
.gotobj
)->got
;
3811 info
.gp
= (sgot
->output_section
->vma
3812 + sgot
->output_offset
3816 /* Get the section contents. */
3817 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
3818 info
.contents
= elf_section_data (sec
)->this_hdr
.contents
;
3821 if (!bfd_malloc_and_get_section (abfd
, sec
, &info
.contents
))
3825 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
3828 struct alpha_elf_got_entry
*gotent
;
3829 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
3830 unsigned long r_symndx
= ELF64_R_SYM (irel
->r_info
);
3832 /* Early exit for unhandled or unrelaxable relocations. */
3833 if (r_type
!= R_ALPHA_LITERAL
)
3835 /* We complete everything except LITERAL in the first pass. */
3836 if (relax_pass
!= 0)
3838 if (r_type
== R_ALPHA_TLSLDM
)
3840 /* The symbol for a TLSLDM reloc is ignored. Collapse the
3841 reloc to the STN_UNDEF (0) symbol so that they all match. */
3842 r_symndx
= STN_UNDEF
;
3844 else if (r_type
!= R_ALPHA_GOTDTPREL
3845 && r_type
!= R_ALPHA_GOTTPREL
3846 && r_type
!= R_ALPHA_TLSGD
)
3850 /* Get the value of the symbol referred to by the reloc. */
3851 if (r_symndx
< symtab_hdr
->sh_info
)
3853 /* A local symbol. */
3854 Elf_Internal_Sym
*isym
;
3856 /* Read this BFD's local symbols. */
3857 if (isymbuf
== NULL
)
3859 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3860 if (isymbuf
== NULL
)
3861 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3862 symtab_hdr
->sh_info
, 0,
3864 if (isymbuf
== NULL
)
3868 isym
= isymbuf
+ r_symndx
;
3870 /* Given the symbol for a TLSLDM reloc is ignored, this also
3871 means forcing the symbol value to the tp base. */
3872 if (r_type
== R_ALPHA_TLSLDM
)
3874 info
.tsec
= bfd_abs_section_ptr
;
3875 symval
= alpha_get_tprel_base (info
.link_info
);
3879 symval
= isym
->st_value
;
3880 if (isym
->st_shndx
== SHN_UNDEF
)
3882 else if (isym
->st_shndx
== SHN_ABS
)
3883 info
.tsec
= bfd_abs_section_ptr
;
3884 else if (isym
->st_shndx
== SHN_COMMON
)
3885 info
.tsec
= bfd_com_section_ptr
;
3887 info
.tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
3891 info
.other
= isym
->st_other
;
3892 if (local_got_entries
)
3893 info
.first_gotent
= &local_got_entries
[r_symndx
];
3896 info
.first_gotent
= &info
.gotent
;
3903 struct alpha_elf_link_hash_entry
*h
;
3905 indx
= r_symndx
- symtab_hdr
->sh_info
;
3906 h
= alpha_elf_sym_hashes (abfd
)[indx
];
3907 BFD_ASSERT (h
!= NULL
);
3909 while (h
->root
.root
.type
== bfd_link_hash_indirect
3910 || h
->root
.root
.type
== bfd_link_hash_warning
)
3911 h
= (struct alpha_elf_link_hash_entry
*)h
->root
.root
.u
.i
.link
;
3913 /* If the symbol is undefined, we can't do anything with it. */
3914 if (h
->root
.root
.type
== bfd_link_hash_undefined
)
3917 /* If the symbol isn't defined in the current module,
3918 again we can't do anything. */
3919 if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
3921 info
.tsec
= bfd_abs_section_ptr
;
3924 else if (!h
->root
.def_regular
)
3926 /* Except for TLSGD relocs, which can sometimes be
3927 relaxed to GOTTPREL relocs. */
3928 if (r_type
!= R_ALPHA_TLSGD
)
3930 info
.tsec
= bfd_abs_section_ptr
;
3935 info
.tsec
= h
->root
.root
.u
.def
.section
;
3936 symval
= h
->root
.root
.u
.def
.value
;
3940 info
.other
= h
->root
.other
;
3941 info
.first_gotent
= &h
->got_entries
;
3944 /* Search for the got entry to be used by this relocation. */
3945 for (gotent
= *info
.first_gotent
; gotent
; gotent
= gotent
->next
)
3946 if (gotent
->gotobj
== info
.gotobj
3947 && gotent
->reloc_type
== r_type
3948 && gotent
->addend
== irel
->r_addend
)
3950 info
.gotent
= gotent
;
3952 symval
+= info
.tsec
->output_section
->vma
+ info
.tsec
->output_offset
;
3953 symval
+= irel
->r_addend
;
3957 case R_ALPHA_LITERAL
:
3958 BFD_ASSERT(info
.gotent
!= NULL
);
3960 /* If there exist LITUSE relocations immediately following, this
3961 opens up all sorts of interesting optimizations, because we
3962 now know every location that this address load is used. */
3963 if (irel
+1 < irelend
3964 && ELF64_R_TYPE (irel
[1].r_info
) == R_ALPHA_LITUSE
)
3966 if (!elf64_alpha_relax_with_lituse (&info
, symval
, irel
))
3971 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
3976 case R_ALPHA_GOTDTPREL
:
3977 case R_ALPHA_GOTTPREL
:
3978 BFD_ASSERT(info
.gotent
!= NULL
);
3979 if (!elf64_alpha_relax_got_load (&info
, symval
, irel
, r_type
))
3984 case R_ALPHA_TLSLDM
:
3985 BFD_ASSERT(info
.gotent
!= NULL
);
3986 if (!elf64_alpha_relax_tls_get_addr (&info
, symval
, irel
,
3987 r_type
== R_ALPHA_TLSGD
))
3994 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3996 if (!link_info
->keep_memory
)
4000 /* Cache the symbols for elf_link_input_bfd. */
4001 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
4005 if (info
.contents
!= NULL
4006 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
4008 if (!info
.changed_contents
&& !link_info
->keep_memory
)
4009 free (info
.contents
);
4012 /* Cache the section contents for elf_link_input_bfd. */
4013 elf_section_data (sec
)->this_hdr
.contents
= info
.contents
;
4017 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
4019 if (!info
.changed_relocs
)
4020 free (internal_relocs
);
4022 elf_section_data (sec
)->relocs
= internal_relocs
;
4025 *again
= info
.changed_contents
|| info
.changed_relocs
;
4031 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
4033 if (info
.contents
!= NULL
4034 && elf_section_data (sec
)->this_hdr
.contents
!= info
.contents
)
4035 free (info
.contents
);
4036 if (internal_relocs
!= NULL
4037 && elf_section_data (sec
)->relocs
!= internal_relocs
)
4038 free (internal_relocs
);
4042 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4043 into the next available slot in SREL. */
4046 elf64_alpha_emit_dynrel (bfd
*abfd
, struct bfd_link_info
*info
,
4047 asection
*sec
, asection
*srel
, bfd_vma offset
,
4048 long dynindx
, long rtype
, bfd_vma addend
)
4050 Elf_Internal_Rela outrel
;
4053 BFD_ASSERT (srel
!= NULL
);
4055 outrel
.r_info
= ELF64_R_INFO (dynindx
, rtype
);
4056 outrel
.r_addend
= addend
;
4058 offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
4059 if ((offset
| 1) != (bfd_vma
) -1)
4060 outrel
.r_offset
= sec
->output_section
->vma
+ sec
->output_offset
+ offset
;
4062 memset (&outrel
, 0, sizeof (outrel
));
4064 loc
= srel
->contents
;
4065 loc
+= srel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
4066 bfd_elf64_swap_reloca_out (abfd
, &outrel
, loc
);
4067 BFD_ASSERT (sizeof (Elf64_External_Rela
) * srel
->reloc_count
<= srel
->size
);
4070 /* Relocate an Alpha ELF section for a relocatable link.
4072 We don't have to change anything unless the reloc is against a section
4073 symbol, in which case we have to adjust according to where the section
4074 symbol winds up in the output section. */
4077 elf64_alpha_relocate_section_r (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4078 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4079 bfd
*input_bfd
, asection
*input_section
,
4080 bfd_byte
*contents ATTRIBUTE_UNUSED
,
4081 Elf_Internal_Rela
*relocs
,
4082 Elf_Internal_Sym
*local_syms
,
4083 asection
**local_sections
)
4085 unsigned long symtab_hdr_sh_info
;
4086 Elf_Internal_Rela
*rel
;
4087 Elf_Internal_Rela
*relend
;
4088 struct elf_link_hash_entry
**sym_hashes
;
4089 bfd_boolean ret_val
= TRUE
;
4091 symtab_hdr_sh_info
= elf_symtab_hdr (input_bfd
).sh_info
;
4092 sym_hashes
= elf_sym_hashes (input_bfd
);
4094 relend
= relocs
+ input_section
->reloc_count
;
4095 for (rel
= relocs
; rel
< relend
; rel
++)
4097 unsigned long r_symndx
;
4098 Elf_Internal_Sym
*sym
;
4100 unsigned long r_type
;
4102 r_type
= ELF64_R_TYPE (rel
->r_info
);
4103 if (r_type
>= R_ALPHA_max
)
4106 /* xgettext:c-format */
4107 (_("%pB: unsupported relocation type %#x"),
4108 input_bfd
, (int) r_type
);
4109 bfd_set_error (bfd_error_bad_value
);
4114 /* The symbol associated with GPDISP and LITUSE is
4115 immaterial. Only the addend is significant. */
4116 if (r_type
== R_ALPHA_GPDISP
|| r_type
== R_ALPHA_LITUSE
)
4119 r_symndx
= ELF64_R_SYM (rel
->r_info
);
4120 if (r_symndx
< symtab_hdr_sh_info
)
4122 sym
= local_syms
+ r_symndx
;
4123 sec
= local_sections
[r_symndx
];
4127 struct elf_link_hash_entry
*h
;
4129 h
= sym_hashes
[r_symndx
- symtab_hdr_sh_info
];
4131 while (h
->root
.type
== bfd_link_hash_indirect
4132 || h
->root
.type
== bfd_link_hash_warning
)
4133 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4135 if (h
->root
.type
!= bfd_link_hash_defined
4136 && h
->root
.type
!= bfd_link_hash_defweak
)
4140 sec
= h
->root
.u
.def
.section
;
4143 if (sec
!= NULL
&& discarded_section (sec
))
4144 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
4146 elf64_alpha_howto_table
+ r_type
, 0,
4149 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
4150 rel
->r_addend
+= sec
->output_offset
;
4156 /* Relocate an Alpha ELF section. */
4159 elf64_alpha_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
4160 bfd
*input_bfd
, asection
*input_section
,
4161 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
4162 Elf_Internal_Sym
*local_syms
,
4163 asection
**local_sections
)
4165 Elf_Internal_Shdr
*symtab_hdr
;
4166 Elf_Internal_Rela
*rel
;
4167 Elf_Internal_Rela
*relend
;
4168 asection
*sgot
, *srel
, *srelgot
;
4169 bfd
*dynobj
, *gotobj
;
4170 bfd_vma gp
, tp_base
, dtp_base
;
4171 struct alpha_elf_got_entry
**local_got_entries
;
4172 bfd_boolean ret_val
;
4174 BFD_ASSERT (is_alpha_elf (input_bfd
));
4176 /* Handle relocatable links with a smaller loop. */
4177 if (bfd_link_relocatable (info
))
4178 return elf64_alpha_relocate_section_r (output_bfd
, info
, input_bfd
,
4179 input_section
, contents
, relocs
,
4180 local_syms
, local_sections
);
4182 /* This is a final link. */
4186 symtab_hdr
= &elf_symtab_hdr (input_bfd
);
4188 dynobj
= elf_hash_table (info
)->dynobj
;
4189 srelgot
= elf_hash_table (info
)->srelgot
;
4191 if (input_section
->flags
& SEC_ALLOC
)
4193 const char *section_name
;
4194 section_name
= (bfd_elf_string_from_elf_section
4195 (input_bfd
, elf_elfheader(input_bfd
)->e_shstrndx
,
4196 _bfd_elf_single_rel_hdr (input_section
)->sh_name
));
4197 BFD_ASSERT(section_name
!= NULL
);
4198 srel
= bfd_get_linker_section (dynobj
, section_name
);
4203 /* Find the gp value for this input bfd. */
4204 gotobj
= alpha_elf_tdata (input_bfd
)->gotobj
;
4207 sgot
= alpha_elf_tdata (gotobj
)->got
;
4208 gp
= _bfd_get_gp_value (gotobj
);
4211 gp
= (sgot
->output_section
->vma
4212 + sgot
->output_offset
4214 _bfd_set_gp_value (gotobj
, gp
);
4223 local_got_entries
= alpha_elf_tdata(input_bfd
)->local_got_entries
;
4225 if (elf_hash_table (info
)->tls_sec
!= NULL
)
4227 dtp_base
= alpha_get_dtprel_base (info
);
4228 tp_base
= alpha_get_tprel_base (info
);
4231 dtp_base
= tp_base
= 0;
4233 relend
= relocs
+ input_section
->reloc_count
;
4234 for (rel
= relocs
; rel
< relend
; rel
++)
4236 struct alpha_elf_link_hash_entry
*h
= NULL
;
4237 struct alpha_elf_got_entry
*gotent
;
4238 bfd_reloc_status_type r
;
4239 reloc_howto_type
*howto
;
4240 unsigned long r_symndx
;
4241 Elf_Internal_Sym
*sym
= NULL
;
4242 asection
*sec
= NULL
;
4245 bfd_boolean dynamic_symbol_p
;
4246 bfd_boolean unresolved_reloc
= FALSE
;
4247 bfd_boolean undef_weak_ref
= FALSE
;
4248 unsigned long r_type
;
4250 r_type
= ELF64_R_TYPE(rel
->r_info
);
4251 if (r_type
>= R_ALPHA_max
)
4254 /* xgettext:c-format */
4255 (_("%pB: unsupported relocation type %#x"),
4256 input_bfd
, (int) r_type
);
4257 bfd_set_error (bfd_error_bad_value
);
4262 howto
= elf64_alpha_howto_table
+ r_type
;
4263 r_symndx
= ELF64_R_SYM(rel
->r_info
);
4265 /* The symbol for a TLSLDM reloc is ignored. Collapse the
4266 reloc to the STN_UNDEF (0) symbol so that they all match. */
4267 if (r_type
== R_ALPHA_TLSLDM
)
4268 r_symndx
= STN_UNDEF
;
4270 if (r_symndx
< symtab_hdr
->sh_info
)
4273 sym
= local_syms
+ r_symndx
;
4274 sec
= local_sections
[r_symndx
];
4276 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
4278 /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4279 this is hackery from relax_section. Force the value to
4280 be the tls module base. */
4281 if (r_symndx
== STN_UNDEF
4282 && (r_type
== R_ALPHA_TLSLDM
4283 || r_type
== R_ALPHA_GOTTPREL
4284 || r_type
== R_ALPHA_TPREL64
4285 || r_type
== R_ALPHA_TPRELHI
4286 || r_type
== R_ALPHA_TPRELLO
4287 || r_type
== R_ALPHA_TPREL16
))
4290 if (local_got_entries
)
4291 gotent
= local_got_entries
[r_symndx
];
4295 /* Need to adjust local GOT entries' addends for SEC_MERGE
4296 unless it has been done already. */
4297 if ((sec
->flags
& SEC_MERGE
)
4298 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
4299 && sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4301 && !gotent
->reloc_xlated
)
4303 struct alpha_elf_got_entry
*ent
;
4305 for (ent
= gotent
; ent
; ent
= ent
->next
)
4307 ent
->reloc_xlated
= 1;
4308 if (ent
->use_count
== 0)
4312 _bfd_merged_section_offset (output_bfd
, &msec
,
4313 elf_section_data (sec
)->
4315 sym
->st_value
+ ent
->addend
);
4316 ent
->addend
-= sym
->st_value
;
4317 ent
->addend
+= msec
->output_section
->vma
4318 + msec
->output_offset
4319 - sec
->output_section
->vma
4320 - sec
->output_offset
;
4324 dynamic_symbol_p
= FALSE
;
4328 bfd_boolean warned
, ignored
;
4329 struct elf_link_hash_entry
*hh
;
4330 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
4332 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4333 r_symndx
, symtab_hdr
, sym_hashes
,
4335 unresolved_reloc
, warned
, ignored
);
4341 && ! unresolved_reloc
4342 && hh
->root
.type
== bfd_link_hash_undefweak
)
4343 undef_weak_ref
= TRUE
;
4345 h
= (struct alpha_elf_link_hash_entry
*) hh
;
4346 dynamic_symbol_p
= alpha_elf_dynamic_symbol_p (&h
->root
, info
);
4347 gotent
= h
->got_entries
;
4350 if (sec
!= NULL
&& discarded_section (sec
))
4351 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
4352 rel
, 1, relend
, howto
, 0, contents
);
4354 addend
= rel
->r_addend
;
4357 /* Search for the proper got entry. */
4358 for (; gotent
; gotent
= gotent
->next
)
4359 if (gotent
->gotobj
== gotobj
4360 && gotent
->reloc_type
== r_type
4361 && gotent
->addend
== addend
)
4366 case R_ALPHA_GPDISP
:
4368 bfd_byte
*p_ldah
, *p_lda
;
4370 BFD_ASSERT(gp
!= 0);
4372 value
= (input_section
->output_section
->vma
4373 + input_section
->output_offset
4376 p_ldah
= contents
+ rel
->r_offset
;
4377 p_lda
= p_ldah
+ rel
->r_addend
;
4379 r
= elf64_alpha_do_reloc_gpdisp (input_bfd
, gp
- value
,
4384 case R_ALPHA_LITERAL
:
4385 BFD_ASSERT(sgot
!= NULL
);
4386 BFD_ASSERT(gp
!= 0);
4387 BFD_ASSERT(gotent
!= NULL
);
4388 BFD_ASSERT(gotent
->use_count
>= 1);
4390 if (!gotent
->reloc_done
)
4392 gotent
->reloc_done
= 1;
4394 bfd_put_64 (output_bfd
, value
,
4395 sgot
->contents
+ gotent
->got_offset
);
4397 /* If the symbol has been forced local, output a
4398 RELATIVE reloc, otherwise it will be handled in
4399 finish_dynamic_symbol. */
4400 if (bfd_link_pic (info
)
4401 && !dynamic_symbol_p
4403 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4404 gotent
->got_offset
, 0,
4405 R_ALPHA_RELATIVE
, value
);
4408 value
= (sgot
->output_section
->vma
4409 + sgot
->output_offset
4410 + gotent
->got_offset
);
4414 case R_ALPHA_GPREL32
:
4415 case R_ALPHA_GPREL16
:
4416 case R_ALPHA_GPRELLOW
:
4417 if (dynamic_symbol_p
)
4420 /* xgettext:c-format */
4421 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4422 input_bfd
, h
->root
.root
.root
.string
);
4425 BFD_ASSERT(gp
!= 0);
4429 case R_ALPHA_GPRELHIGH
:
4430 if (dynamic_symbol_p
)
4433 /* xgettext:c-format */
4434 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4435 input_bfd
, h
->root
.root
.root
.string
);
4438 BFD_ASSERT(gp
!= 0);
4440 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4444 /* A call to a dynamic symbol is definitely out of range of
4445 the 16-bit displacement. Don't bother writing anything. */
4446 if (dynamic_symbol_p
)
4451 /* The regular PC-relative stuff measures from the start of
4452 the instruction rather than the end. */
4456 case R_ALPHA_BRADDR
:
4457 if (dynamic_symbol_p
)
4460 /* xgettext:c-format */
4461 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4462 input_bfd
, h
->root
.root
.root
.string
);
4465 /* The regular PC-relative stuff measures from the start of
4466 the instruction rather than the end. */
4475 /* The regular PC-relative stuff measures from the start of
4476 the instruction rather than the end. */
4479 /* The source and destination gp must be the same. Note that
4480 the source will always have an assigned gp, since we forced
4481 one in check_relocs, but that the destination may not, as
4482 it might not have had any relocations at all. Also take
4483 care not to crash if H is an undefined symbol. */
4484 if (h
!= NULL
&& sec
!= NULL
4485 && alpha_elf_tdata (sec
->owner
)->gotobj
4486 && gotobj
!= alpha_elf_tdata (sec
->owner
)->gotobj
)
4489 /* xgettext:c-format */
4490 (_("%pB: change in gp: BRSGP %s"),
4491 input_bfd
, h
->root
.root
.root
.string
);
4495 /* The symbol should be marked either NOPV or STD_GPLOAD. */
4497 other
= h
->root
.other
;
4499 other
= sym
->st_other
;
4500 switch (other
& STO_ALPHA_STD_GPLOAD
)
4502 case STO_ALPHA_NOPV
:
4504 case STO_ALPHA_STD_GPLOAD
:
4509 name
= h
->root
.root
.root
.string
;
4512 name
= (bfd_elf_string_from_elf_section
4513 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4515 name
= _("<unknown>");
4516 else if (name
[0] == 0)
4517 name
= bfd_section_name (sec
);
4520 /* xgettext:c-format */
4521 (_("%pB: !samegp reloc against symbol without .prologue: %s"),
4530 case R_ALPHA_REFLONG
:
4531 case R_ALPHA_REFQUAD
:
4532 case R_ALPHA_DTPREL64
:
4533 case R_ALPHA_TPREL64
:
4535 long dynindx
, dyntype
= r_type
;
4538 /* Careful here to remember RELATIVE relocations for global
4539 variables for symbolic shared objects. */
4541 if (dynamic_symbol_p
)
4543 BFD_ASSERT(h
->root
.dynindx
!= -1);
4544 dynindx
= h
->root
.dynindx
;
4546 addend
= 0, value
= 0;
4548 else if (r_type
== R_ALPHA_DTPREL64
)
4550 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4554 else if (r_type
== R_ALPHA_TPREL64
)
4556 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4557 if (!bfd_link_dll (info
))
4563 dynaddend
= value
- dtp_base
;
4565 else if (bfd_link_pic (info
)
4566 && r_symndx
!= STN_UNDEF
4567 && (input_section
->flags
& SEC_ALLOC
)
4569 && !(unresolved_reloc
4570 && (_bfd_elf_section_offset (output_bfd
, info
,
4575 if (r_type
== R_ALPHA_REFLONG
)
4578 /* xgettext:c-format */
4579 (_("%pB: unhandled dynamic relocation against %s"),
4581 h
->root
.root
.root
.string
);
4585 dyntype
= R_ALPHA_RELATIVE
;
4591 if (input_section
->flags
& SEC_ALLOC
)
4592 elf64_alpha_emit_dynrel (output_bfd
, info
, input_section
,
4593 srel
, rel
->r_offset
, dynindx
,
4594 dyntype
, dynaddend
);
4598 case R_ALPHA_SREL16
:
4599 case R_ALPHA_SREL32
:
4600 case R_ALPHA_SREL64
:
4601 if (dynamic_symbol_p
)
4604 /* xgettext:c-format */
4605 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4606 input_bfd
, h
->root
.root
.root
.string
);
4609 else if (bfd_link_pic (info
)
4613 /* xgettext:c-format */
4614 (_("%pB: pc-relative relocation against undefined weak symbol %s"),
4615 input_bfd
, h
->root
.root
.root
.string
);
4620 /* ??? .eh_frame references to discarded sections will be smashed
4621 to relocations against SHN_UNDEF. The .eh_frame format allows
4622 NULL to be encoded as 0 in any format, so this works here. */
4623 if (r_symndx
== STN_UNDEF
4624 || (unresolved_reloc
4625 && _bfd_elf_section_offset (output_bfd
, info
,
4627 rel
->r_offset
) == (bfd_vma
) -1))
4628 howto
= (elf64_alpha_howto_table
4629 + (r_type
- R_ALPHA_SREL32
+ R_ALPHA_REFLONG
));
4632 case R_ALPHA_TLSLDM
:
4633 /* Ignore the symbol for the relocation. The result is always
4634 the current module. */
4635 dynamic_symbol_p
= 0;
4639 if (!gotent
->reloc_done
)
4641 gotent
->reloc_done
= 1;
4643 /* Note that the module index for the main program is 1. */
4644 bfd_put_64 (output_bfd
,
4645 !bfd_link_pic (info
) && !dynamic_symbol_p
,
4646 sgot
->contents
+ gotent
->got_offset
);
4648 /* If the symbol has been forced local, output a
4649 DTPMOD64 reloc, otherwise it will be handled in
4650 finish_dynamic_symbol. */
4651 if (bfd_link_pic (info
) && !dynamic_symbol_p
)
4652 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4653 gotent
->got_offset
, 0,
4654 R_ALPHA_DTPMOD64
, 0);
4656 if (dynamic_symbol_p
|| r_type
== R_ALPHA_TLSLDM
)
4660 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4663 bfd_put_64 (output_bfd
, value
,
4664 sgot
->contents
+ gotent
->got_offset
+ 8);
4667 value
= (sgot
->output_section
->vma
4668 + sgot
->output_offset
4669 + gotent
->got_offset
);
4673 case R_ALPHA_DTPRELHI
:
4674 case R_ALPHA_DTPRELLO
:
4675 case R_ALPHA_DTPREL16
:
4676 if (dynamic_symbol_p
)
4679 /* xgettext:c-format */
4680 (_("%pB: dtp-relative relocation against dynamic symbol %s"),
4681 input_bfd
, h
->root
.root
.root
.string
);
4684 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4686 if (r_type
== R_ALPHA_DTPRELHI
)
4687 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4690 case R_ALPHA_TPRELHI
:
4691 case R_ALPHA_TPRELLO
:
4692 case R_ALPHA_TPREL16
:
4693 if (bfd_link_dll (info
))
4696 /* xgettext:c-format */
4697 (_("%pB: TLS local exec code cannot be linked into shared objects"),
4701 else if (dynamic_symbol_p
)
4704 /* xgettext:c-format */
4705 (_("%pB: tp-relative relocation against dynamic symbol %s"),
4706 input_bfd
, h
->root
.root
.root
.string
);
4709 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4711 if (r_type
== R_ALPHA_TPRELHI
)
4712 value
= ((bfd_signed_vma
) value
>> 16) + ((value
>> 15) & 1);
4715 case R_ALPHA_GOTDTPREL
:
4716 case R_ALPHA_GOTTPREL
:
4717 BFD_ASSERT(sgot
!= NULL
);
4718 BFD_ASSERT(gp
!= 0);
4719 BFD_ASSERT(gotent
!= NULL
);
4720 BFD_ASSERT(gotent
->use_count
>= 1);
4722 if (!gotent
->reloc_done
)
4724 gotent
->reloc_done
= 1;
4726 if (dynamic_symbol_p
)
4730 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
4731 if (r_type
== R_ALPHA_GOTDTPREL
)
4733 else if (bfd_link_executable (info
))
4737 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srelgot
,
4738 gotent
->got_offset
, 0,
4744 bfd_put_64 (output_bfd
, value
,
4745 sgot
->contents
+ gotent
->got_offset
);
4748 value
= (sgot
->output_section
->vma
4749 + sgot
->output_offset
4750 + gotent
->got_offset
);
4756 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
4757 contents
, rel
->r_offset
, value
, 0);
4766 case bfd_reloc_overflow
:
4770 /* Don't warn if the overflow is due to pc relative reloc
4771 against discarded section. Section optimization code should
4774 if (r_symndx
< symtab_hdr
->sh_info
4775 && sec
!= NULL
&& howto
->pc_relative
4776 && discarded_section (sec
))
4783 name
= (bfd_elf_string_from_elf_section
4784 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
4788 name
= bfd_section_name (sec
);
4790 (*info
->callbacks
->reloc_overflow
)
4791 (info
, (h
? &h
->root
.root
: NULL
), name
, howto
->name
,
4792 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
4797 case bfd_reloc_outofrange
:
4805 /* Finish up dynamic symbol handling. We set the contents of various
4806 dynamic sections here. */
4809 elf64_alpha_finish_dynamic_symbol (bfd
*output_bfd
, struct bfd_link_info
*info
,
4810 struct elf_link_hash_entry
*h
,
4811 Elf_Internal_Sym
*sym
)
4813 struct alpha_elf_link_hash_entry
*ah
= (struct alpha_elf_link_hash_entry
*)h
;
4817 /* Fill in the .plt entry for this symbol. */
4818 asection
*splt
, *sgot
, *srel
;
4819 Elf_Internal_Rela outrel
;
4821 bfd_vma got_addr
, plt_addr
;
4823 struct alpha_elf_got_entry
*gotent
;
4825 BFD_ASSERT (h
->dynindx
!= -1);
4827 splt
= elf_hash_table (info
)->splt
;
4828 BFD_ASSERT (splt
!= NULL
);
4829 srel
= elf_hash_table (info
)->srelplt
;
4830 BFD_ASSERT (srel
!= NULL
);
4832 for (gotent
= ah
->got_entries
; gotent
; gotent
= gotent
->next
)
4833 if (gotent
->reloc_type
== R_ALPHA_LITERAL
4834 && gotent
->use_count
> 0)
4839 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4840 BFD_ASSERT (sgot
!= NULL
);
4842 BFD_ASSERT (gotent
->got_offset
!= -1);
4843 BFD_ASSERT (gotent
->plt_offset
!= -1);
4845 got_addr
= (sgot
->output_section
->vma
4846 + sgot
->output_offset
4847 + gotent
->got_offset
);
4848 plt_addr
= (splt
->output_section
->vma
4849 + splt
->output_offset
4850 + gotent
->plt_offset
);
4852 plt_index
= (gotent
->plt_offset
-PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
4854 /* Fill in the entry in the procedure linkage table. */
4855 if (elf64_alpha_use_secureplt
)
4857 disp
= (PLT_HEADER_SIZE
- 4) - (gotent
->plt_offset
+ 4);
4858 insn
= INSN_AD (INSN_BR
, 31, disp
);
4859 bfd_put_32 (output_bfd
, insn
,
4860 splt
->contents
+ gotent
->plt_offset
);
4862 plt_index
= ((gotent
->plt_offset
- NEW_PLT_HEADER_SIZE
)
4863 / NEW_PLT_ENTRY_SIZE
);
4867 disp
= -(gotent
->plt_offset
+ 4);
4868 insn
= INSN_AD (INSN_BR
, 28, disp
);
4869 bfd_put_32 (output_bfd
, insn
,
4870 splt
->contents
+ gotent
->plt_offset
);
4871 bfd_put_32 (output_bfd
, INSN_UNOP
,
4872 splt
->contents
+ gotent
->plt_offset
+ 4);
4873 bfd_put_32 (output_bfd
, INSN_UNOP
,
4874 splt
->contents
+ gotent
->plt_offset
+ 8);
4876 plt_index
= ((gotent
->plt_offset
- OLD_PLT_HEADER_SIZE
)
4877 / OLD_PLT_ENTRY_SIZE
);
4880 /* Fill in the entry in the .rela.plt section. */
4881 outrel
.r_offset
= got_addr
;
4882 outrel
.r_info
= ELF64_R_INFO(h
->dynindx
, R_ALPHA_JMP_SLOT
);
4883 outrel
.r_addend
= 0;
4885 loc
= srel
->contents
+ plt_index
* sizeof (Elf64_External_Rela
);
4886 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
4888 /* Fill in the entry in the .got. */
4889 bfd_put_64 (output_bfd
, plt_addr
,
4890 sgot
->contents
+ gotent
->got_offset
);
4893 else if (alpha_elf_dynamic_symbol_p (h
, info
))
4895 /* Fill in the dynamic relocations for this symbol's .got entries. */
4897 struct alpha_elf_got_entry
*gotent
;
4899 srel
= elf_hash_table (info
)->srelgot
;
4900 BFD_ASSERT (srel
!= NULL
);
4902 for (gotent
= ((struct alpha_elf_link_hash_entry
*) h
)->got_entries
;
4904 gotent
= gotent
->next
)
4909 if (gotent
->use_count
== 0)
4912 sgot
= alpha_elf_tdata (gotent
->gotobj
)->got
;
4914 r_type
= gotent
->reloc_type
;
4917 case R_ALPHA_LITERAL
:
4918 r_type
= R_ALPHA_GLOB_DAT
;
4921 r_type
= R_ALPHA_DTPMOD64
;
4923 case R_ALPHA_GOTDTPREL
:
4924 r_type
= R_ALPHA_DTPREL64
;
4926 case R_ALPHA_GOTTPREL
:
4927 r_type
= R_ALPHA_TPREL64
;
4929 case R_ALPHA_TLSLDM
:
4934 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4935 gotent
->got_offset
, h
->dynindx
,
4936 r_type
, gotent
->addend
);
4938 if (gotent
->reloc_type
== R_ALPHA_TLSGD
)
4939 elf64_alpha_emit_dynrel (output_bfd
, info
, sgot
, srel
,
4940 gotent
->got_offset
+ 8, h
->dynindx
,
4941 R_ALPHA_DTPREL64
, gotent
->addend
);
4945 /* Mark some specially defined symbols as absolute. */
4946 if (h
== elf_hash_table (info
)->hdynamic
4947 || h
== elf_hash_table (info
)->hgot
4948 || h
== elf_hash_table (info
)->hplt
)
4949 sym
->st_shndx
= SHN_ABS
;
4954 /* Finish up the dynamic sections. */
4957 elf64_alpha_finish_dynamic_sections (bfd
*output_bfd
,
4958 struct bfd_link_info
*info
)
4963 dynobj
= elf_hash_table (info
)->dynobj
;
4964 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4966 if (elf_hash_table (info
)->dynamic_sections_created
)
4968 asection
*splt
, *sgotplt
, *srelaplt
;
4969 Elf64_External_Dyn
*dyncon
, *dynconend
;
4970 bfd_vma plt_vma
, gotplt_vma
;
4972 splt
= elf_hash_table (info
)->splt
;
4973 srelaplt
= elf_hash_table (info
)->srelplt
;
4974 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
4976 plt_vma
= splt
->output_section
->vma
+ splt
->output_offset
;
4979 if (elf64_alpha_use_secureplt
)
4981 sgotplt
= elf_hash_table (info
)->sgotplt
;
4982 BFD_ASSERT (sgotplt
!= NULL
);
4983 if (sgotplt
->size
> 0)
4984 gotplt_vma
= sgotplt
->output_section
->vma
+ sgotplt
->output_offset
;
4987 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
4988 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4989 for (; dyncon
< dynconend
; dyncon
++)
4991 Elf_Internal_Dyn dyn
;
4993 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4999 = elf64_alpha_use_secureplt
? gotplt_vma
: plt_vma
;
5002 dyn
.d_un
.d_val
= srelaplt
? srelaplt
->size
: 0;
5005 dyn
.d_un
.d_ptr
= srelaplt
? (srelaplt
->output_section
->vma
5006 + srelaplt
->output_offset
) : 0;
5010 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5013 /* Initialize the plt header. */
5019 if (elf64_alpha_use_secureplt
)
5021 ofs
= gotplt_vma
- (plt_vma
+ PLT_HEADER_SIZE
);
5023 insn
= INSN_ABC (INSN_SUBQ
, 27, 28, 25);
5024 bfd_put_32 (output_bfd
, insn
, splt
->contents
);
5026 insn
= INSN_ABO (INSN_LDAH
, 28, 28, (ofs
+ 0x8000) >> 16);
5027 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 4);
5029 insn
= INSN_ABC (INSN_S4SUBQ
, 25, 25, 25);
5030 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 8);
5032 insn
= INSN_ABO (INSN_LDA
, 28, 28, ofs
);
5033 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 12);
5035 insn
= INSN_ABO (INSN_LDQ
, 27, 28, 0);
5036 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 16);
5038 insn
= INSN_ABC (INSN_ADDQ
, 25, 25, 25);
5039 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 20);
5041 insn
= INSN_ABO (INSN_LDQ
, 28, 28, 8);
5042 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 24);
5044 insn
= INSN_AB (INSN_JMP
, 31, 27);
5045 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 28);
5047 insn
= INSN_AD (INSN_BR
, 28, -PLT_HEADER_SIZE
);
5048 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 32);
5052 insn
= INSN_AD (INSN_BR
, 27, 0); /* br $27, .+4 */
5053 bfd_put_32 (output_bfd
, insn
, splt
->contents
);
5055 insn
= INSN_ABO (INSN_LDQ
, 27, 27, 12);
5056 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 4);
5059 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 8);
5061 insn
= INSN_AB (INSN_JMP
, 27, 27);
5062 bfd_put_32 (output_bfd
, insn
, splt
->contents
+ 12);
5064 /* The next two words will be filled in by ld.so. */
5065 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 16);
5066 bfd_put_64 (output_bfd
, 0, splt
->contents
+ 24);
5069 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 0;
5076 /* We need to use a special link routine to handle the .mdebug section.
5077 We need to merge all instances of these sections together, not write
5078 them all out sequentially. */
5081 elf64_alpha_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
5084 struct bfd_link_order
*p
;
5085 asection
*mdebug_sec
;
5086 struct ecoff_debug_info debug
;
5087 const struct ecoff_debug_swap
*swap
5088 = get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
5089 HDRR
*symhdr
= &debug
.symbolic_header
;
5090 void * mdebug_handle
= NULL
;
5091 struct alpha_elf_link_hash_table
* htab
;
5093 htab
= alpha_elf_hash_table (info
);
5097 /* Go through the sections and collect the mdebug information. */
5099 for (o
= abfd
->sections
; o
!= (asection
*) NULL
; o
= o
->next
)
5101 if (strcmp (o
->name
, ".mdebug") == 0)
5103 struct extsym_info einfo
;
5105 /* We have found the .mdebug section in the output file.
5106 Look through all the link_orders comprising it and merge
5107 the information together. */
5108 symhdr
->magic
= swap
->sym_magic
;
5109 /* FIXME: What should the version stamp be? */
5111 symhdr
->ilineMax
= 0;
5115 symhdr
->isymMax
= 0;
5116 symhdr
->ioptMax
= 0;
5117 symhdr
->iauxMax
= 0;
5119 symhdr
->issExtMax
= 0;
5122 symhdr
->iextMax
= 0;
5124 /* We accumulate the debugging information itself in the
5125 debug_info structure. */
5127 debug
.external_dnr
= NULL
;
5128 debug
.external_pdr
= NULL
;
5129 debug
.external_sym
= NULL
;
5130 debug
.external_opt
= NULL
;
5131 debug
.external_aux
= NULL
;
5133 debug
.ssext
= debug
.ssext_end
= NULL
;
5134 debug
.external_fdr
= NULL
;
5135 debug
.external_rfd
= NULL
;
5136 debug
.external_ext
= debug
.external_ext_end
= NULL
;
5138 mdebug_handle
= bfd_ecoff_debug_init (abfd
, &debug
, swap
, info
);
5139 if (mdebug_handle
== NULL
)
5148 static const char * const name
[] =
5150 ".text", ".init", ".fini", ".data",
5151 ".rodata", ".sdata", ".sbss", ".bss"
5153 static const int sc
[] = { scText
, scInit
, scFini
, scData
,
5154 scRData
, scSData
, scSBss
, scBss
};
5157 esym
.cobol_main
= 0;
5161 esym
.asym
.iss
= issNil
;
5162 esym
.asym
.st
= stLocal
;
5163 esym
.asym
.reserved
= 0;
5164 esym
.asym
.index
= indexNil
;
5165 for (i
= 0; i
< 8; i
++)
5167 esym
.asym
.sc
= sc
[i
];
5168 s
= bfd_get_section_by_name (abfd
, name
[i
]);
5171 esym
.asym
.value
= s
->vma
;
5172 last
= s
->vma
+ s
->size
;
5175 esym
.asym
.value
= last
;
5177 if (! bfd_ecoff_debug_one_external (abfd
, &debug
, swap
,
5183 for (p
= o
->map_head
.link_order
;
5184 p
!= (struct bfd_link_order
*) NULL
;
5187 asection
*input_section
;
5189 const struct ecoff_debug_swap
*input_swap
;
5190 struct ecoff_debug_info input_debug
;
5194 if (p
->type
!= bfd_indirect_link_order
)
5196 if (p
->type
== bfd_data_link_order
)
5201 input_section
= p
->u
.indirect
.section
;
5202 input_bfd
= input_section
->owner
;
5204 if (! is_alpha_elf (input_bfd
))
5205 /* I don't know what a non ALPHA ELF bfd would be
5206 doing with a .mdebug section, but I don't really
5207 want to deal with it. */
5210 input_swap
= (get_elf_backend_data (input_bfd
)
5211 ->elf_backend_ecoff_debug_swap
);
5213 BFD_ASSERT (p
->size
== input_section
->size
);
5215 /* The ECOFF linking code expects that we have already
5216 read in the debugging information and set up an
5217 ecoff_debug_info structure, so we do that now. */
5218 if (!elf64_alpha_read_ecoff_info (input_bfd
, input_section
,
5222 if (! (bfd_ecoff_debug_accumulate
5223 (mdebug_handle
, abfd
, &debug
, swap
, input_bfd
,
5224 &input_debug
, input_swap
, info
)))
5227 /* Loop through the external symbols. For each one with
5228 interesting information, try to find the symbol in
5229 the linker global hash table and save the information
5230 for the output external symbols. */
5231 eraw_src
= (char *) input_debug
.external_ext
;
5232 eraw_end
= (eraw_src
5233 + (input_debug
.symbolic_header
.iextMax
5234 * input_swap
->external_ext_size
));
5236 eraw_src
< eraw_end
;
5237 eraw_src
+= input_swap
->external_ext_size
)
5241 struct alpha_elf_link_hash_entry
*h
;
5243 (*input_swap
->swap_ext_in
) (input_bfd
, eraw_src
, &ext
);
5244 if (ext
.asym
.sc
== scNil
5245 || ext
.asym
.sc
== scUndefined
5246 || ext
.asym
.sc
== scSUndefined
)
5249 name
= input_debug
.ssext
+ ext
.asym
.iss
;
5250 h
= alpha_elf_link_hash_lookup (htab
, name
, FALSE
, FALSE
, TRUE
);
5251 if (h
== NULL
|| h
->esym
.ifd
!= -2)
5257 < input_debug
.symbolic_header
.ifdMax
);
5258 ext
.ifd
= input_debug
.ifdmap
[ext
.ifd
];
5264 /* Free up the information we just read. */
5265 free (input_debug
.line
);
5266 free (input_debug
.external_dnr
);
5267 free (input_debug
.external_pdr
);
5268 free (input_debug
.external_sym
);
5269 free (input_debug
.external_opt
);
5270 free (input_debug
.external_aux
);
5271 free (input_debug
.ss
);
5272 free (input_debug
.ssext
);
5273 free (input_debug
.external_fdr
);
5274 free (input_debug
.external_rfd
);
5275 free (input_debug
.external_ext
);
5277 /* Hack: reset the SEC_HAS_CONTENTS flag so that
5278 elf_link_input_bfd ignores this section. */
5279 input_section
->flags
&=~ SEC_HAS_CONTENTS
;
5282 /* Build the external symbol information. */
5285 einfo
.debug
= &debug
;
5287 einfo
.failed
= FALSE
;
5288 elf_link_hash_traverse (elf_hash_table (info
),
5289 elf64_alpha_output_extsym
,
5294 /* Set the size of the .mdebug section. */
5295 o
->size
= bfd_ecoff_debug_size (abfd
, &debug
, swap
);
5297 /* Skip this section later on (I don't think this currently
5298 matters, but someday it might). */
5299 o
->map_head
.link_order
= (struct bfd_link_order
*) NULL
;
5305 /* Invoke the regular ELF backend linker to do all the work. */
5306 if (! bfd_elf_final_link (abfd
, info
))
5309 /* Now write out the computed sections. */
5311 /* The .got subsections... */
5313 bfd
*i
, *dynobj
= elf_hash_table(info
)->dynobj
;
5314 for (i
= htab
->got_list
;
5316 i
= alpha_elf_tdata(i
)->got_link_next
)
5320 /* elf_bfd_final_link already did everything in dynobj. */
5324 sgot
= alpha_elf_tdata(i
)->got
;
5325 if (! bfd_set_section_contents (abfd
, sgot
->output_section
,
5327 (file_ptr
) sgot
->output_offset
,
5333 if (mdebug_sec
!= (asection
*) NULL
)
5335 BFD_ASSERT (abfd
->output_has_begun
);
5336 if (! bfd_ecoff_write_accumulated_debug (mdebug_handle
, abfd
, &debug
,
5338 mdebug_sec
->filepos
))
5341 bfd_ecoff_debug_free (mdebug_handle
, abfd
, &debug
, swap
, info
);
5347 static enum elf_reloc_type_class
5348 elf64_alpha_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5349 const asection
*rel_sec ATTRIBUTE_UNUSED
,
5350 const Elf_Internal_Rela
*rela
)
5352 switch ((int) ELF64_R_TYPE (rela
->r_info
))
5354 case R_ALPHA_RELATIVE
:
5355 return reloc_class_relative
;
5356 case R_ALPHA_JMP_SLOT
:
5357 return reloc_class_plt
;
5359 return reloc_class_copy
;
5361 return reloc_class_normal
;
5365 static const struct bfd_elf_special_section elf64_alpha_special_sections
[] =
5367 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5368 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_ALPHA_GPREL
},
5369 { NULL
, 0, 0, 0, 0 }
5372 /* ECOFF swapping routines. These are used when dealing with the
5373 .mdebug section, which is in the ECOFF debugging format. Copied
5374 from elf32-mips.c. */
5375 static const struct ecoff_debug_swap
5376 elf64_alpha_ecoff_debug_swap
=
5378 /* Symbol table magic number. */
5380 /* Alignment of debugging information. E.g., 4. */
5382 /* Sizes of external symbolic information. */
5383 sizeof (struct hdr_ext
),
5384 sizeof (struct dnr_ext
),
5385 sizeof (struct pdr_ext
),
5386 sizeof (struct sym_ext
),
5387 sizeof (struct opt_ext
),
5388 sizeof (struct fdr_ext
),
5389 sizeof (struct rfd_ext
),
5390 sizeof (struct ext_ext
),
5391 /* Functions to swap in external symbolic data. */
5400 _bfd_ecoff_swap_tir_in
,
5401 _bfd_ecoff_swap_rndx_in
,
5402 /* Functions to swap out external symbolic data. */
5411 _bfd_ecoff_swap_tir_out
,
5412 _bfd_ecoff_swap_rndx_out
,
5413 /* Function to read in symbolic data. */
5414 elf64_alpha_read_ecoff_info
5417 /* Use a non-standard hash bucket size of 8. */
5419 static const struct elf_size_info alpha_elf_size_info
=
5421 sizeof (Elf64_External_Ehdr
),
5422 sizeof (Elf64_External_Phdr
),
5423 sizeof (Elf64_External_Shdr
),
5424 sizeof (Elf64_External_Rel
),
5425 sizeof (Elf64_External_Rela
),
5426 sizeof (Elf64_External_Sym
),
5427 sizeof (Elf64_External_Dyn
),
5428 sizeof (Elf_External_Note
),
5432 ELFCLASS64
, EV_CURRENT
,
5433 bfd_elf64_write_out_phdrs
,
5434 bfd_elf64_write_shdrs_and_ehdr
,
5435 bfd_elf64_checksum_contents
,
5436 bfd_elf64_write_relocs
,
5437 bfd_elf64_swap_symbol_in
,
5438 bfd_elf64_swap_symbol_out
,
5439 bfd_elf64_slurp_reloc_table
,
5440 bfd_elf64_slurp_symbol_table
,
5441 bfd_elf64_swap_dyn_in
,
5442 bfd_elf64_swap_dyn_out
,
5443 bfd_elf64_swap_reloc_in
,
5444 bfd_elf64_swap_reloc_out
,
5445 bfd_elf64_swap_reloca_in
,
5446 bfd_elf64_swap_reloca_out
5449 #define TARGET_LITTLE_SYM alpha_elf64_vec
5450 #define TARGET_LITTLE_NAME "elf64-alpha"
5451 #define ELF_ARCH bfd_arch_alpha
5452 #define ELF_TARGET_ID ALPHA_ELF_DATA
5453 #define ELF_MACHINE_CODE EM_ALPHA
5454 #define ELF_MAXPAGESIZE 0x10000
5455 #define ELF_COMMONPAGESIZE 0x2000
5457 #define bfd_elf64_bfd_link_hash_table_create \
5458 elf64_alpha_bfd_link_hash_table_create
5460 #define bfd_elf64_bfd_reloc_type_lookup \
5461 elf64_alpha_bfd_reloc_type_lookup
5462 #define bfd_elf64_bfd_reloc_name_lookup \
5463 elf64_alpha_bfd_reloc_name_lookup
5464 #define elf_info_to_howto \
5465 elf64_alpha_info_to_howto
5467 #define bfd_elf64_mkobject \
5468 elf64_alpha_mkobject
5469 #define elf_backend_object_p \
5470 elf64_alpha_object_p
5472 #define elf_backend_section_from_shdr \
5473 elf64_alpha_section_from_shdr
5474 #define elf_backend_section_flags \
5475 elf64_alpha_section_flags
5476 #define elf_backend_fake_sections \
5477 elf64_alpha_fake_sections
5479 #define bfd_elf64_bfd_is_local_label_name \
5480 elf64_alpha_is_local_label_name
5481 #define bfd_elf64_find_nearest_line \
5482 elf64_alpha_find_nearest_line
5483 #define bfd_elf64_bfd_relax_section \
5484 elf64_alpha_relax_section
5486 #define elf_backend_add_symbol_hook \
5487 elf64_alpha_add_symbol_hook
5488 #define elf_backend_relocs_compatible \
5489 _bfd_elf_relocs_compatible
5490 #define elf_backend_sort_relocs_p \
5491 elf64_alpha_sort_relocs_p
5492 #define elf_backend_check_relocs \
5493 elf64_alpha_check_relocs
5494 #define elf_backend_create_dynamic_sections \
5495 elf64_alpha_create_dynamic_sections
5496 #define elf_backend_adjust_dynamic_symbol \
5497 elf64_alpha_adjust_dynamic_symbol
5498 #define elf_backend_merge_symbol_attribute \
5499 elf64_alpha_merge_symbol_attribute
5500 #define elf_backend_copy_indirect_symbol \
5501 elf64_alpha_copy_indirect_symbol
5502 #define elf_backend_always_size_sections \
5503 elf64_alpha_always_size_sections
5504 #define elf_backend_size_dynamic_sections \
5505 elf64_alpha_size_dynamic_sections
5506 #define elf_backend_omit_section_dynsym \
5507 _bfd_elf_omit_section_dynsym_all
5508 #define elf_backend_relocate_section \
5509 elf64_alpha_relocate_section
5510 #define elf_backend_finish_dynamic_symbol \
5511 elf64_alpha_finish_dynamic_symbol
5512 #define elf_backend_finish_dynamic_sections \
5513 elf64_alpha_finish_dynamic_sections
5514 #define bfd_elf64_bfd_final_link \
5515 elf64_alpha_final_link
5516 #define elf_backend_reloc_type_class \
5517 elf64_alpha_reloc_type_class
5519 #define elf_backend_can_gc_sections 1
5520 #define elf_backend_gc_mark_hook elf64_alpha_gc_mark_hook
5522 #define elf_backend_ecoff_debug_swap \
5523 &elf64_alpha_ecoff_debug_swap
5525 #define elf_backend_size_info \
5528 #define elf_backend_special_sections \
5529 elf64_alpha_special_sections
5531 /* A few constants that determine how the .plt section is set up. */
5532 #define elf_backend_want_got_plt 0
5533 #define elf_backend_plt_readonly 0
5534 #define elf_backend_want_plt_sym 1
5535 #define elf_backend_got_header_size 0
5536 #define elf_backend_dtrel_excludes_plt 1
5538 #include "elf64-target.h"
5540 /* FreeBSD support. */
5542 #undef TARGET_LITTLE_SYM
5543 #define TARGET_LITTLE_SYM alpha_elf64_fbsd_vec
5544 #undef TARGET_LITTLE_NAME
5545 #define TARGET_LITTLE_NAME "elf64-alpha-freebsd"
5547 #define ELF_OSABI ELFOSABI_FREEBSD
5549 /* The kernel recognizes executables as valid only if they carry a
5550 "FreeBSD" label in the ELF header. So we put this label on all
5551 executables and (for simplicity) also all other object files. */
5554 elf64_alpha_fbsd_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
5556 Elf_Internal_Ehdr
* i_ehdrp
; /* ELF file header, internal form. */
5558 if (!_bfd_elf_init_file_header (abfd
, info
))
5561 i_ehdrp
= elf_elfheader (abfd
);
5563 /* Put an ABI label supported by FreeBSD >= 4.1. */
5564 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
5565 #ifdef OLD_FREEBSD_ABI_LABEL
5566 /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard. */
5567 memcpy (&i_ehdrp
->e_ident
[EI_ABIVERSION
], "FreeBSD", 8);
5572 #undef elf_backend_init_file_header
5573 #define elf_backend_init_file_header \
5574 elf64_alpha_fbsd_init_file_header
5577 #define elf64_bed elf64_alpha_fbsd_bed
5579 #include "elf64-target.h"