1 /* BFD back-end for ALPHA Extended-Coff files.
2 Copyright (C) 1993-2023 Free Software Foundation, Inc.
3 Modified from coff-mips.c by Steve Chamberlain <sac@cygnus.com> and
4 Ian Lance Taylor <ian@cygnus.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "coff/internal.h"
29 #include "coff/symconst.h"
30 #include "coff/ecoff.h"
31 #include "coff/alpha.h"
36 /* Prototypes for static functions. */
40 /* ECOFF has COFF sections, but the debugging information is stored in
41 a completely different format. ECOFF targets use some of the
42 swapping routines from coffswap.h, and some of the generic COFF
43 routines in coffgen.c, but, unlike the real COFF targets, do not
44 use coffcode.h itself.
46 Get the generic COFF swapping routines, except for the reloc,
47 symbol, and lineno ones. Give them ecoff names. Define some
48 accessor macros for the large sizes used for Alpha ECOFF. */
50 #define GET_FILEHDR_SYMPTR H_GET_64
51 #define PUT_FILEHDR_SYMPTR H_PUT_64
52 #define GET_AOUTHDR_TSIZE H_GET_64
53 #define PUT_AOUTHDR_TSIZE H_PUT_64
54 #define GET_AOUTHDR_DSIZE H_GET_64
55 #define PUT_AOUTHDR_DSIZE H_PUT_64
56 #define GET_AOUTHDR_BSIZE H_GET_64
57 #define PUT_AOUTHDR_BSIZE H_PUT_64
58 #define GET_AOUTHDR_ENTRY H_GET_64
59 #define PUT_AOUTHDR_ENTRY H_PUT_64
60 #define GET_AOUTHDR_TEXT_START H_GET_64
61 #define PUT_AOUTHDR_TEXT_START H_PUT_64
62 #define GET_AOUTHDR_DATA_START H_GET_64
63 #define PUT_AOUTHDR_DATA_START H_PUT_64
64 #define GET_SCNHDR_PADDR H_GET_64
65 #define PUT_SCNHDR_PADDR H_PUT_64
66 #define GET_SCNHDR_VADDR H_GET_64
67 #define PUT_SCNHDR_VADDR H_PUT_64
68 #define GET_SCNHDR_SIZE H_GET_64
69 #define PUT_SCNHDR_SIZE H_PUT_64
70 #define GET_SCNHDR_SCNPTR H_GET_64
71 #define PUT_SCNHDR_SCNPTR H_PUT_64
72 #define GET_SCNHDR_RELPTR H_GET_64
73 #define PUT_SCNHDR_RELPTR H_PUT_64
74 #define GET_SCNHDR_LNNOPTR H_GET_64
75 #define PUT_SCNHDR_LNNOPTR H_PUT_64
79 #define NO_COFF_RELOCS
80 #define NO_COFF_SYMBOLS
81 #define NO_COFF_LINENOS
82 #define coff_swap_filehdr_in alpha_ecoff_swap_filehdr_in
83 #define coff_swap_filehdr_out alpha_ecoff_swap_filehdr_out
84 #define coff_swap_aouthdr_in alpha_ecoff_swap_aouthdr_in
85 #define coff_swap_aouthdr_out alpha_ecoff_swap_aouthdr_out
86 #define coff_swap_scnhdr_in alpha_ecoff_swap_scnhdr_in
87 #define coff_swap_scnhdr_out alpha_ecoff_swap_scnhdr_out
90 /* Get the ECOFF swapping routines. */
92 #include "ecoffswap.h"
94 /* How to process the various reloc types. */
96 static bfd_reloc_status_type
97 reloc_nil (bfd
*abfd ATTRIBUTE_UNUSED
,
98 arelent
*reloc ATTRIBUTE_UNUSED
,
99 asymbol
*sym ATTRIBUTE_UNUSED
,
100 void * data ATTRIBUTE_UNUSED
,
101 asection
*sec ATTRIBUTE_UNUSED
,
102 bfd
*output_bfd ATTRIBUTE_UNUSED
,
103 char **error_message ATTRIBUTE_UNUSED
)
108 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
109 from smaller values. Start with zero, widen, *then* decrement. */
110 #define MINUS_ONE (((bfd_vma)0) - 1)
112 static reloc_howto_type alpha_howto_table
[] =
114 /* Reloc type 0 is ignored by itself. However, it appears after a
115 GPDISP reloc to identify the location where the low order 16 bits
116 of the gp register are loaded. */
117 HOWTO (ALPHA_R_IGNORE
, /* type */
121 true, /* pc_relative */
123 complain_overflow_dont
, /* complain_on_overflow */
124 reloc_nil
, /* special_function */
126 true, /* partial_inplace */
129 true), /* pcrel_offset */
131 /* A 32 bit reference to a symbol. */
132 HOWTO (ALPHA_R_REFLONG
, /* type */
136 false, /* pc_relative */
138 complain_overflow_bitfield
, /* complain_on_overflow */
139 0, /* special_function */
140 "REFLONG", /* name */
141 true, /* partial_inplace */
142 0xffffffff, /* src_mask */
143 0xffffffff, /* dst_mask */
144 false), /* pcrel_offset */
146 /* A 64 bit reference to a symbol. */
147 HOWTO (ALPHA_R_REFQUAD
, /* type */
151 false, /* pc_relative */
153 complain_overflow_bitfield
, /* complain_on_overflow */
154 0, /* special_function */
155 "REFQUAD", /* name */
156 true, /* partial_inplace */
157 MINUS_ONE
, /* src_mask */
158 MINUS_ONE
, /* dst_mask */
159 false), /* pcrel_offset */
161 /* A 32 bit GP relative offset. This is just like REFLONG except
162 that when the value is used the value of the gp register will be
164 HOWTO (ALPHA_R_GPREL32
, /* type */
168 false, /* pc_relative */
170 complain_overflow_bitfield
, /* complain_on_overflow */
171 0, /* special_function */
172 "GPREL32", /* name */
173 true, /* partial_inplace */
174 0xffffffff, /* src_mask */
175 0xffffffff, /* dst_mask */
176 false), /* pcrel_offset */
178 /* Used for an instruction that refers to memory off the GP
179 register. The offset is 16 bits of the 32 bit instruction. This
180 reloc always seems to be against the .lita section. */
181 HOWTO (ALPHA_R_LITERAL
, /* type */
185 false, /* pc_relative */
187 complain_overflow_signed
, /* complain_on_overflow */
188 0, /* special_function */
189 "LITERAL", /* name */
190 true, /* partial_inplace */
191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
193 false), /* pcrel_offset */
195 /* This reloc only appears immediately following a LITERAL reloc.
196 It identifies a use of the literal. It seems that the linker can
197 use this to eliminate a portion of the .lita section. The symbol
198 index is special: 1 means the literal address is in the base
199 register of a memory format instruction; 2 means the literal
200 address is in the byte offset register of a byte-manipulation
201 instruction; 3 means the literal address is in the target
202 register of a jsr instruction. This does not actually do any
204 HOWTO (ALPHA_R_LITUSE
, /* type */
208 false, /* pc_relative */
210 complain_overflow_dont
, /* complain_on_overflow */
211 reloc_nil
, /* special_function */
213 false, /* partial_inplace */
216 false), /* pcrel_offset */
218 /* Load the gp register. This is always used for a ldah instruction
219 which loads the upper 16 bits of the gp register. The next reloc
220 will be an IGNORE reloc which identifies the location of the lda
221 instruction which loads the lower 16 bits. The symbol index of
222 the GPDISP instruction appears to actually be the number of bytes
223 between the ldah and lda instructions. This gives two different
224 ways to determine where the lda instruction is; I don't know why
225 both are used. The value to use for the relocation is the
226 difference between the GP value and the current location; the
227 load will always be done against a register holding the current
229 HOWTO (ALPHA_R_GPDISP
, /* type */
233 true, /* pc_relative */
235 complain_overflow_dont
, /* complain_on_overflow */
236 reloc_nil
, /* special_function */
238 true, /* partial_inplace */
239 0xffff, /* src_mask */
240 0xffff, /* dst_mask */
241 true), /* pcrel_offset */
243 /* A 21 bit branch. The native assembler generates these for
244 branches within the text segment, and also fills in the PC
245 relative offset in the instruction. */
246 HOWTO (ALPHA_R_BRADDR
, /* type */
250 true, /* pc_relative */
252 complain_overflow_signed
, /* complain_on_overflow */
253 0, /* special_function */
255 true, /* partial_inplace */
256 0x1fffff, /* src_mask */
257 0x1fffff, /* dst_mask */
258 false), /* pcrel_offset */
260 /* A hint for a jump to a register. */
261 HOWTO (ALPHA_R_HINT
, /* type */
265 true, /* pc_relative */
267 complain_overflow_dont
, /* complain_on_overflow */
268 0, /* special_function */
270 true, /* partial_inplace */
271 0x3fff, /* src_mask */
272 0x3fff, /* dst_mask */
273 false), /* pcrel_offset */
275 /* 16 bit PC relative offset. */
276 HOWTO (ALPHA_R_SREL16
, /* type */
280 true, /* pc_relative */
282 complain_overflow_signed
, /* complain_on_overflow */
283 0, /* special_function */
285 true, /* partial_inplace */
286 0xffff, /* src_mask */
287 0xffff, /* dst_mask */
288 false), /* pcrel_offset */
290 /* 32 bit PC relative offset. */
291 HOWTO (ALPHA_R_SREL32
, /* type */
295 true, /* pc_relative */
297 complain_overflow_signed
, /* complain_on_overflow */
298 0, /* special_function */
300 true, /* partial_inplace */
301 0xffffffff, /* src_mask */
302 0xffffffff, /* dst_mask */
303 false), /* pcrel_offset */
305 /* A 64 bit PC relative offset. */
306 HOWTO (ALPHA_R_SREL64
, /* type */
310 true, /* pc_relative */
312 complain_overflow_signed
, /* complain_on_overflow */
313 0, /* special_function */
315 true, /* partial_inplace */
316 MINUS_ONE
, /* src_mask */
317 MINUS_ONE
, /* dst_mask */
318 false), /* pcrel_offset */
320 /* Push a value on the reloc evaluation stack. */
321 HOWTO (ALPHA_R_OP_PUSH
, /* type */
325 false, /* pc_relative */
327 complain_overflow_dont
, /* complain_on_overflow */
328 0, /* special_function */
329 "OP_PUSH", /* name */
330 false, /* partial_inplace */
333 false), /* pcrel_offset */
335 /* Store the value from the stack at the given address. Store it in
336 a bitfield of size r_size starting at bit position r_offset. */
337 HOWTO (ALPHA_R_OP_STORE
, /* type */
341 false, /* pc_relative */
343 complain_overflow_dont
, /* complain_on_overflow */
344 0, /* special_function */
345 "OP_STORE", /* name */
346 false, /* partial_inplace */
348 MINUS_ONE
, /* dst_mask */
349 false), /* pcrel_offset */
351 /* Subtract the reloc address from the value on the top of the
353 HOWTO (ALPHA_R_OP_PSUB
, /* type */
357 false, /* pc_relative */
359 complain_overflow_dont
, /* complain_on_overflow */
360 0, /* special_function */
361 "OP_PSUB", /* name */
362 false, /* partial_inplace */
365 false), /* pcrel_offset */
367 /* Shift the value on the top of the relocation stack right by the
369 HOWTO (ALPHA_R_OP_PRSHIFT
, /* type */
373 false, /* pc_relative */
375 complain_overflow_dont
, /* complain_on_overflow */
376 0, /* special_function */
377 "OP_PRSHIFT", /* name */
378 false, /* partial_inplace */
381 false), /* pcrel_offset */
383 /* Adjust the GP value for a new range in the object file. */
384 HOWTO (ALPHA_R_GPVALUE
, /* type */
388 false, /* pc_relative */
390 complain_overflow_dont
, /* complain_on_overflow */
391 0, /* special_function */
392 "GPVALUE", /* name */
393 false, /* partial_inplace */
396 false) /* pcrel_offset */
399 /* Recognize an Alpha ECOFF file. */
402 alpha_ecoff_object_p (bfd
*abfd
)
406 ret
= coff_object_p (abfd
);
412 /* Alpha ECOFF has a .pdata section. The lnnoptr field of the
413 .pdata section is the number of entries it contains. Each
414 entry takes up 8 bytes. The number of entries is required
415 since the section is aligned to a 16 byte boundary. When we
416 link .pdata sections together, we do not want to include the
417 alignment bytes. We handle this on input by faking the size
418 of the .pdata section to remove the unwanted alignment bytes.
419 On output we will set the lnnoptr field and force the
421 sec
= bfd_get_section_by_name (abfd
, _PDATA
);
422 if (sec
!= (asection
*) NULL
)
426 size
= (bfd_size_type
) sec
->line_filepos
* 8;
427 BFD_ASSERT (size
== sec
->size
428 || size
+ 8 == sec
->size
);
429 if (!bfd_set_section_size (sec
, size
))
437 /* See whether the magic number matches. */
440 alpha_ecoff_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
443 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
445 if (! ALPHA_ECOFF_BADMAG (*internal_f
))
448 if (ALPHA_ECOFF_COMPRESSEDMAG (*internal_f
))
450 (_("%pB: cannot handle compressed Alpha binaries; "
451 "use compiler flags, or objZ, to generate uncompressed binaries"),
457 /* This is a hook called by coff_real_object_p to create any backend
458 specific information. */
461 alpha_ecoff_mkobject_hook (bfd
*abfd
, void * filehdr
, void * aouthdr
)
465 ecoff
= _bfd_ecoff_mkobject_hook (abfd
, filehdr
, aouthdr
);
469 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
471 /* Set additional BFD flags according to the object type from the
472 machine specific file header flags. */
473 switch (internal_f
->f_flags
& F_ALPHA_OBJECT_TYPE_MASK
)
475 case F_ALPHA_SHARABLE
:
476 abfd
->flags
|= DYNAMIC
;
478 case F_ALPHA_CALL_SHARED
:
479 /* Always executable if using shared libraries as the run time
480 loader might resolve undefined references. */
481 abfd
->flags
|= (DYNAMIC
| EXEC_P
);
488 /* Reloc handling. */
490 /* Swap a reloc in. */
493 alpha_ecoff_swap_reloc_in (bfd
*abfd
,
495 struct internal_reloc
*intern
)
497 const RELOC
*ext
= (RELOC
*) ext_ptr
;
499 intern
->r_vaddr
= H_GET_64 (abfd
, ext
->r_vaddr
);
500 intern
->r_symndx
= H_GET_32 (abfd
, ext
->r_symndx
);
502 BFD_ASSERT (bfd_header_little_endian (abfd
));
504 intern
->r_type
= ((ext
->r_bits
[0] & RELOC_BITS0_TYPE_LITTLE
)
505 >> RELOC_BITS0_TYPE_SH_LITTLE
);
506 intern
->r_extern
= (ext
->r_bits
[1] & RELOC_BITS1_EXTERN_LITTLE
) != 0;
507 intern
->r_offset
= ((ext
->r_bits
[1] & RELOC_BITS1_OFFSET_LITTLE
)
508 >> RELOC_BITS1_OFFSET_SH_LITTLE
);
509 /* Ignored the reserved bits. */
510 intern
->r_size
= ((ext
->r_bits
[3] & RELOC_BITS3_SIZE_LITTLE
)
511 >> RELOC_BITS3_SIZE_SH_LITTLE
);
513 if (intern
->r_type
== ALPHA_R_LITUSE
514 || intern
->r_type
== ALPHA_R_GPDISP
)
516 /* Handle the LITUSE and GPDISP relocs specially. Its symndx
517 value is not actually a symbol index, but is instead a
518 special code. We put the code in the r_size field, and
519 clobber the symndx. */
520 if (intern
->r_size
!= 0)
522 intern
->r_size
= intern
->r_symndx
;
523 intern
->r_symndx
= RELOC_SECTION_NONE
;
525 else if (intern
->r_type
== ALPHA_R_IGNORE
)
527 /* The IGNORE reloc generally follows a GPDISP reloc, and is
528 against the .lita section. The section is irrelevant. */
529 if (! intern
->r_extern
&&
530 intern
->r_symndx
== RELOC_SECTION_ABS
)
532 if (! intern
->r_extern
&& intern
->r_symndx
== RELOC_SECTION_LITA
)
533 intern
->r_symndx
= RELOC_SECTION_ABS
;
537 /* Swap a reloc out. */
540 alpha_ecoff_swap_reloc_out (bfd
*abfd
,
541 const struct internal_reloc
*intern
,
544 RELOC
*ext
= (RELOC
*) dst
;
548 /* Undo the hackery done in swap_reloc_in. */
549 if (intern
->r_type
== ALPHA_R_LITUSE
550 || intern
->r_type
== ALPHA_R_GPDISP
)
552 symndx
= intern
->r_size
;
555 else if (intern
->r_type
== ALPHA_R_IGNORE
556 && ! intern
->r_extern
557 && intern
->r_symndx
== RELOC_SECTION_ABS
)
559 symndx
= RELOC_SECTION_LITA
;
560 size
= intern
->r_size
;
564 symndx
= intern
->r_symndx
;
565 size
= intern
->r_size
;
568 /* XXX FIXME: The maximum symndx value used to be 14 but this
569 fails with object files produced by DEC's C++ compiler.
570 Where does the value 14 (or 15) come from anyway ? */
571 BFD_ASSERT (intern
->r_extern
572 || (intern
->r_symndx
>= 0 && intern
->r_symndx
<= 15));
574 H_PUT_64 (abfd
, intern
->r_vaddr
, ext
->r_vaddr
);
575 H_PUT_32 (abfd
, symndx
, ext
->r_symndx
);
577 BFD_ASSERT (bfd_header_little_endian (abfd
));
579 ext
->r_bits
[0] = ((intern
->r_type
<< RELOC_BITS0_TYPE_SH_LITTLE
)
580 & RELOC_BITS0_TYPE_LITTLE
);
581 ext
->r_bits
[1] = ((intern
->r_extern
? RELOC_BITS1_EXTERN_LITTLE
: 0)
582 | ((intern
->r_offset
<< RELOC_BITS1_OFFSET_SH_LITTLE
)
583 & RELOC_BITS1_OFFSET_LITTLE
));
585 ext
->r_bits
[3] = ((size
<< RELOC_BITS3_SIZE_SH_LITTLE
)
586 & RELOC_BITS3_SIZE_LITTLE
);
589 /* Finish canonicalizing a reloc. Part of this is generic to all
590 ECOFF targets, and that part is in ecoff.c. The rest is done in
591 this backend routine. It must fill in the howto field. */
594 alpha_adjust_reloc_in (bfd
*abfd
,
595 const struct internal_reloc
*intern
,
598 if (intern
->r_type
> ALPHA_R_GPVALUE
)
600 /* xgettext:c-format */
601 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
602 abfd
, intern
->r_type
);
603 bfd_set_error (bfd_error_bad_value
);
609 switch (intern
->r_type
)
615 /* This relocs appear to be fully resolved when they are against
616 internal symbols. Against external symbols, BRADDR at least
617 appears to be resolved against the next instruction. */
618 if (! intern
->r_extern
)
621 rptr
->addend
= - (intern
->r_vaddr
+ 4);
624 case ALPHA_R_GPREL32
:
625 case ALPHA_R_LITERAL
:
626 /* Copy the gp value for this object file into the addend, to
627 ensure that we are not confused by the linker. */
628 if (! intern
->r_extern
)
629 rptr
->addend
+= ecoff_data (abfd
)->gp
;
634 /* The LITUSE and GPDISP relocs do not use a symbol, or an
635 addend, but they do use a special code. Put this code in the
637 rptr
->addend
= intern
->r_size
;
640 case ALPHA_R_OP_STORE
:
641 /* The STORE reloc needs the size and offset fields. We store
642 them in the addend. */
643 BFD_ASSERT (intern
->r_offset
<= 256);
644 rptr
->addend
= (intern
->r_offset
<< 8) + intern
->r_size
;
647 case ALPHA_R_OP_PUSH
:
648 case ALPHA_R_OP_PSUB
:
649 case ALPHA_R_OP_PRSHIFT
:
650 /* The PUSH, PSUB and PRSHIFT relocs do not actually use an
651 address. I believe that the address supplied is really an
653 rptr
->addend
= intern
->r_vaddr
;
656 case ALPHA_R_GPVALUE
:
657 /* Set the addend field to the new GP value. */
658 rptr
->addend
= intern
->r_symndx
+ ecoff_data (abfd
)->gp
;
662 /* If the type is ALPHA_R_IGNORE, make sure this is a reference
663 to the absolute section so that the reloc is ignored. For
664 some reason the address of this reloc type is not adjusted by
665 the section vma. We record the gp value for this object file
666 here, for convenience when doing the GPDISP relocation. */
667 rptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
668 rptr
->address
= intern
->r_vaddr
;
669 rptr
->addend
= ecoff_data (abfd
)->gp
;
676 rptr
->howto
= &alpha_howto_table
[intern
->r_type
];
679 /* When writing out a reloc we need to pull some values back out of
680 the addend field into the reloc. This is roughly the reverse of
681 alpha_adjust_reloc_in, except that there are several changes we do
685 alpha_adjust_reloc_out (bfd
*abfd ATTRIBUTE_UNUSED
,
687 struct internal_reloc
*intern
)
689 switch (intern
->r_type
)
693 intern
->r_size
= rel
->addend
;
696 case ALPHA_R_OP_STORE
:
697 intern
->r_size
= rel
->addend
& 0xff;
698 intern
->r_offset
= (rel
->addend
>> 8) & 0xff;
701 case ALPHA_R_OP_PUSH
:
702 case ALPHA_R_OP_PSUB
:
703 case ALPHA_R_OP_PRSHIFT
:
704 intern
->r_vaddr
= rel
->addend
;
708 intern
->r_vaddr
= rel
->address
;
716 /* The size of the stack for the relocation evaluator. */
717 #define RELOC_STACKSIZE (10)
719 /* Alpha ECOFF relocs have a built in expression evaluator as well as
720 other interdependencies. Rather than use a bunch of special
721 functions and global variables, we use a single routine to do all
722 the relocation for a section. I haven't yet worked out how the
723 assembler is going to handle this. */
726 alpha_ecoff_get_relocated_section_contents (bfd
*abfd
,
727 struct bfd_link_info
*link_info
,
728 struct bfd_link_order
*link_order
,
733 bfd
*input_bfd
= link_order
->u
.indirect
.section
->owner
;
734 asection
*input_section
= link_order
->u
.indirect
.section
;
736 arelent
**reloc_vector
;
738 bfd
*output_bfd
= relocatable
? abfd
: (bfd
*) NULL
;
741 bfd_vma stack
[RELOC_STACKSIZE
];
744 reloc_size
= bfd_get_reloc_upper_bound (input_bfd
, input_section
);
748 bfd_byte
*orig_data
= data
;
749 if (!bfd_get_full_section_contents (input_bfd
, input_section
, &data
))
758 reloc_vector
= (arelent
**) bfd_malloc (reloc_size
);
759 if (reloc_vector
== NULL
)
762 reloc_count
= bfd_canonicalize_reloc (input_bfd
, input_section
,
763 reloc_vector
, symbols
);
766 if (reloc_count
== 0)
767 goto successful_return
;
769 /* Get the GP value for the output BFD. */
770 gp_undefined
= false;
771 gp
= _bfd_get_gp_value (abfd
);
779 /* Make up a value. */
781 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
784 && (strcmp (sec
->name
, ".sbss") == 0
785 || strcmp (sec
->name
, ".sdata") == 0
786 || strcmp (sec
->name
, ".lit4") == 0
787 || strcmp (sec
->name
, ".lit8") == 0
788 || strcmp (sec
->name
, ".lita") == 0))
792 _bfd_set_gp_value (abfd
, gp
);
796 struct bfd_link_hash_entry
*h
;
798 h
= bfd_link_hash_lookup (link_info
->hash
, "_gp", false, false,
800 if (h
== (struct bfd_link_hash_entry
*) NULL
801 || h
->type
!= bfd_link_hash_defined
)
806 + h
->u
.def
.section
->output_section
->vma
807 + h
->u
.def
.section
->output_offset
);
808 _bfd_set_gp_value (abfd
, gp
);
813 for (arelent
**relp
= reloc_vector
; *relp
!= NULL
; relp
++)
816 bfd_reloc_status_type r
;
821 if (rel
->howto
== NULL
)
823 r
= bfd_reloc_notsupported
;
824 r_type
= ALPHA_R_IGNORE
;
829 r_type
= rel
->howto
->type
;
834 rel
->address
+= input_section
->output_offset
;
837 case ALPHA_R_REFLONG
:
838 case ALPHA_R_REFQUAD
:
845 && ((*rel
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) == 0)
847 rel
->address
+= input_section
->output_offset
;
850 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
854 case ALPHA_R_GPREL32
:
855 /* This relocation is used in a switch table. It is a 32
856 bit offset from the current GP value. We must adjust it
857 by the different between the original GP value and the
858 current GP value. The original GP value is stored in the
859 addend. We adjust the addend and let
860 bfd_perform_relocation finish the job. */
862 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
864 if (r
== bfd_reloc_ok
&& gp_undefined
)
866 r
= bfd_reloc_dangerous
;
867 err
= (char *) _("GP relative relocation used when GP not defined");
871 case ALPHA_R_LITERAL
:
872 /* This is a reference to a literal value, generally
873 (always?) in the .lita section. This is a 16 bit GP
874 relative relocation. Sometimes the subsequent reloc is a
875 LITUSE reloc, which indicates how this reloc is used.
876 This sometimes permits rewriting the two instructions
877 referred to by the LITERAL and the LITUSE into different
878 instructions which do not refer to .lita. This can save
879 a memory reference, and permits removing a value from
880 .lita thus saving GP relative space.
882 We do not these optimizations. To do them we would need
883 to arrange to link the .lita section first, so that by
884 the time we got here we would know the final values to
885 use. This would not be particularly difficult, but it is
886 not currently implemented. */
891 /* I believe that the LITERAL reloc will only apply to a
892 ldq or ldl instruction, so check my assumption. */
893 insn
= bfd_get_32 (input_bfd
, data
+ rel
->address
);
894 BFD_ASSERT (((insn
>> 26) & 0x3f) == 0x29
895 || ((insn
>> 26) & 0x3f) == 0x28);
898 r
= bfd_perform_relocation (input_bfd
, rel
, data
, input_section
,
900 if (r
== bfd_reloc_ok
&& gp_undefined
)
902 r
= bfd_reloc_dangerous
;
904 (char *) _("GP relative relocation used when GP not defined");
910 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
911 does not cause anything to happen, itself. */
912 rel
->address
+= input_section
->output_offset
;
916 /* This marks the ldah of an ldah/lda pair which loads the
917 gp register with the difference of the gp value and the
918 current location. The second of the pair is r_size bytes
919 ahead; it used to be marked with an ALPHA_R_IGNORE reloc,
920 but that no longer happens in OSF/1 3.2. */
922 unsigned long insn1
, insn2
;
925 /* Get the two instructions. */
926 insn1
= bfd_get_32 (input_bfd
, data
+ rel
->address
);
927 insn2
= bfd_get_32 (input_bfd
, data
+ rel
->address
+ rel
->addend
);
929 BFD_ASSERT (((insn1
>> 26) & 0x3f) == 0x09); /* ldah */
930 BFD_ASSERT (((insn2
>> 26) & 0x3f) == 0x08); /* lda */
932 /* Get the existing addend. We must account for the sign
933 extension done by lda and ldah. */
934 addend
= ((insn1
& 0xffff) << 16) + (insn2
& 0xffff);
937 addend
-= 0x80000000;
938 addend
-= 0x80000000;
943 /* The existing addend includes the different between the
944 gp of the input BFD and the address in the input BFD.
945 Subtract this out. */
946 addend
-= (ecoff_data (input_bfd
)->gp
947 - (input_section
->vma
+ rel
->address
));
949 /* Now add in the final gp value, and subtract out the
952 - (input_section
->output_section
->vma
953 + input_section
->output_offset
956 /* Change the instructions, accounting for the sign
957 extension, and write them out. */
960 insn1
= (insn1
& 0xffff0000) | ((addend
>> 16) & 0xffff);
961 insn2
= (insn2
& 0xffff0000) | (addend
& 0xffff);
963 bfd_put_32 (input_bfd
, (bfd_vma
) insn1
, data
+ rel
->address
);
964 bfd_put_32 (input_bfd
, (bfd_vma
) insn2
,
965 data
+ rel
->address
+ rel
->addend
);
967 rel
->address
+= input_section
->output_offset
;
971 case ALPHA_R_OP_PUSH
:
972 /* Push a value on the reloc evaluation stack. */
979 rel
->address
+= input_section
->output_offset
;
983 /* Figure out the relocation of this symbol. */
984 symbol
= *rel
->sym_ptr_ptr
;
986 if (bfd_is_und_section (symbol
->section
))
987 r
= bfd_reloc_undefined
;
989 if (bfd_is_com_section (symbol
->section
))
992 relocation
= symbol
->value
;
993 relocation
+= symbol
->section
->output_section
->vma
;
994 relocation
+= symbol
->section
->output_offset
;
995 relocation
+= rel
->addend
;
997 if (tos
>= RELOC_STACKSIZE
)
999 r
= bfd_reloc_notsupported
;
1003 stack
[tos
++] = relocation
;
1007 case ALPHA_R_OP_STORE
:
1008 /* Store a value from the reloc stack into a bitfield. */
1015 rel
->address
+= input_section
->output_offset
;
1021 r
= bfd_reloc_notsupported
;
1025 /* The offset and size for this reloc are encoded into the
1026 addend field by alpha_adjust_reloc_in. */
1027 offset
= (rel
->addend
>> 8) & 0xff;
1028 size
= rel
->addend
& 0xff;
1030 val
= bfd_get_64 (abfd
, data
+ rel
->address
);
1031 val
&=~ (((1 << size
) - 1) << offset
);
1032 val
|= (stack
[--tos
] & ((1 << size
) - 1)) << offset
;
1033 bfd_put_64 (abfd
, val
, data
+ rel
->address
);
1037 case ALPHA_R_OP_PSUB
:
1038 /* Subtract a value from the top of the stack. */
1045 rel
->address
+= input_section
->output_offset
;
1049 /* Figure out the relocation of this symbol. */
1050 symbol
= *rel
->sym_ptr_ptr
;
1052 if (bfd_is_und_section (symbol
->section
))
1053 r
= bfd_reloc_undefined
;
1055 if (bfd_is_com_section (symbol
->section
))
1058 relocation
= symbol
->value
;
1059 relocation
+= symbol
->section
->output_section
->vma
;
1060 relocation
+= symbol
->section
->output_offset
;
1061 relocation
+= rel
->addend
;
1065 r
= bfd_reloc_notsupported
;
1069 stack
[tos
- 1] -= relocation
;
1073 case ALPHA_R_OP_PRSHIFT
:
1074 /* Shift the value on the top of the stack. */
1081 rel
->address
+= input_section
->output_offset
;
1085 /* Figure out the relocation of this symbol. */
1086 symbol
= *rel
->sym_ptr_ptr
;
1088 if (bfd_is_und_section (symbol
->section
))
1089 r
= bfd_reloc_undefined
;
1091 if (bfd_is_com_section (symbol
->section
))
1094 relocation
= symbol
->value
;
1095 relocation
+= symbol
->section
->output_section
->vma
;
1096 relocation
+= symbol
->section
->output_offset
;
1097 relocation
+= rel
->addend
;
1101 r
= bfd_reloc_notsupported
;
1105 stack
[tos
- 1] >>= relocation
;
1109 case ALPHA_R_GPVALUE
:
1110 /* I really don't know if this does the right thing. */
1112 gp_undefined
= false;
1116 r
= bfd_reloc_notsupported
;
1122 asection
*os
= input_section
->output_section
;
1124 /* A partial link, so keep the relocs. */
1125 os
->orelocation
[os
->reloc_count
] = rel
;
1129 if (r
!= bfd_reloc_ok
)
1133 case bfd_reloc_undefined
:
1134 (*link_info
->callbacks
->undefined_symbol
)
1135 (link_info
, bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1136 input_bfd
, input_section
, rel
->address
, true);
1138 case bfd_reloc_dangerous
:
1139 (*link_info
->callbacks
->reloc_dangerous
)
1140 (link_info
, err
, input_bfd
, input_section
, rel
->address
);
1142 case bfd_reloc_overflow
:
1143 (*link_info
->callbacks
->reloc_overflow
)
1144 (link_info
, NULL
, bfd_asymbol_name (*rel
->sym_ptr_ptr
),
1145 rel
->howto
->name
, rel
->addend
, input_bfd
,
1146 input_section
, rel
->address
);
1148 case bfd_reloc_outofrange
:
1149 (*link_info
->callbacks
->einfo
)
1150 /* xgettext:c-format */
1151 (_("%X%P: %pB(%pA): relocation \"%pR\" goes out of range\n"),
1152 abfd
, input_section
, rel
);
1154 case bfd_reloc_notsupported
:
1155 (*link_info
->callbacks
->einfo
)
1156 /* xgettext:c-format */
1157 (_("%X%P: %pB(%pA): relocation \"%pR\" is not supported\n"),
1158 abfd
, input_section
, rel
);
1161 (*link_info
->callbacks
->einfo
)
1162 /* xgettext:c-format */
1163 (_("%X%P: %pB(%pA): relocation \"%pR\""
1164 " returns an unrecognized value %x\n"),
1165 abfd
, input_section
, rel
, r
);
1175 free (reloc_vector
);
1179 free (reloc_vector
);
1180 if (orig_data
== NULL
)
1185 /* Get the howto structure for a generic reloc type. */
1187 static reloc_howto_type
*
1188 alpha_bfd_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1189 bfd_reloc_code_real_type code
)
1196 alpha_type
= ALPHA_R_REFLONG
;
1199 case BFD_RELOC_CTOR
:
1200 alpha_type
= ALPHA_R_REFQUAD
;
1202 case BFD_RELOC_GPREL32
:
1203 alpha_type
= ALPHA_R_GPREL32
;
1205 case BFD_RELOC_ALPHA_LITERAL
:
1206 alpha_type
= ALPHA_R_LITERAL
;
1208 case BFD_RELOC_ALPHA_LITUSE
:
1209 alpha_type
= ALPHA_R_LITUSE
;
1211 case BFD_RELOC_ALPHA_GPDISP_HI16
:
1212 alpha_type
= ALPHA_R_GPDISP
;
1214 case BFD_RELOC_ALPHA_GPDISP_LO16
:
1215 alpha_type
= ALPHA_R_IGNORE
;
1217 case BFD_RELOC_23_PCREL_S2
:
1218 alpha_type
= ALPHA_R_BRADDR
;
1220 case BFD_RELOC_ALPHA_HINT
:
1221 alpha_type
= ALPHA_R_HINT
;
1223 case BFD_RELOC_16_PCREL
:
1224 alpha_type
= ALPHA_R_SREL16
;
1226 case BFD_RELOC_32_PCREL
:
1227 alpha_type
= ALPHA_R_SREL32
;
1229 case BFD_RELOC_64_PCREL
:
1230 alpha_type
= ALPHA_R_SREL64
;
1233 return (reloc_howto_type
*) NULL
;
1236 return &alpha_howto_table
[alpha_type
];
1239 static reloc_howto_type
*
1240 alpha_bfd_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1246 i
< sizeof (alpha_howto_table
) / sizeof (alpha_howto_table
[0]);
1248 if (alpha_howto_table
[i
].name
!= NULL
1249 && strcasecmp (alpha_howto_table
[i
].name
, r_name
) == 0)
1250 return &alpha_howto_table
[i
];
1255 /* A helper routine for alpha_relocate_section which converts an
1256 external reloc when generating relocatable output. Returns the
1257 relocation amount. */
1260 alpha_convert_external_reloc (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1261 struct bfd_link_info
*info
,
1263 struct external_reloc
*ext_rel
,
1264 struct ecoff_link_hash_entry
*h
)
1266 unsigned long r_symndx
;
1269 BFD_ASSERT (bfd_link_relocatable (info
));
1271 if (h
->root
.type
== bfd_link_hash_defined
1272 || h
->root
.type
== bfd_link_hash_defweak
)
1277 /* This symbol is defined in the output. Convert the reloc from
1278 being against the symbol to being against the section. */
1280 /* Clear the r_extern bit. */
1281 ext_rel
->r_bits
[1] &=~ RELOC_BITS1_EXTERN_LITTLE
;
1283 /* Compute a new r_symndx value. */
1284 hsec
= h
->root
.u
.def
.section
;
1285 name
= bfd_section_name (hsec
->output_section
);
1287 r_symndx
= (unsigned long) -1;
1291 if (strcmp (name
, "*ABS*") == 0)
1292 r_symndx
= RELOC_SECTION_ABS
;
1295 if (strcmp (name
, ".bss") == 0)
1296 r_symndx
= RELOC_SECTION_BSS
;
1299 if (strcmp (name
, ".data") == 0)
1300 r_symndx
= RELOC_SECTION_DATA
;
1303 if (strcmp (name
, ".fini") == 0)
1304 r_symndx
= RELOC_SECTION_FINI
;
1307 if (strcmp (name
, ".init") == 0)
1308 r_symndx
= RELOC_SECTION_INIT
;
1311 if (strcmp (name
, ".lita") == 0)
1312 r_symndx
= RELOC_SECTION_LITA
;
1313 else if (strcmp (name
, ".lit8") == 0)
1314 r_symndx
= RELOC_SECTION_LIT8
;
1315 else if (strcmp (name
, ".lit4") == 0)
1316 r_symndx
= RELOC_SECTION_LIT4
;
1319 if (strcmp (name
, ".pdata") == 0)
1320 r_symndx
= RELOC_SECTION_PDATA
;
1323 if (strcmp (name
, ".rdata") == 0)
1324 r_symndx
= RELOC_SECTION_RDATA
;
1325 else if (strcmp (name
, ".rconst") == 0)
1326 r_symndx
= RELOC_SECTION_RCONST
;
1329 if (strcmp (name
, ".sdata") == 0)
1330 r_symndx
= RELOC_SECTION_SDATA
;
1331 else if (strcmp (name
, ".sbss") == 0)
1332 r_symndx
= RELOC_SECTION_SBSS
;
1335 if (strcmp (name
, ".text") == 0)
1336 r_symndx
= RELOC_SECTION_TEXT
;
1339 if (strcmp (name
, ".xdata") == 0)
1340 r_symndx
= RELOC_SECTION_XDATA
;
1344 if (r_symndx
== (unsigned long) -1)
1347 /* Add the section VMA and the symbol value. */
1348 relocation
= (h
->root
.u
.def
.value
1349 + hsec
->output_section
->vma
1350 + hsec
->output_offset
);
1354 /* Change the symndx value to the right one for
1357 if (r_symndx
== (unsigned long) -1)
1359 /* Caller must give an error. */
1365 /* Write out the new r_symndx value. */
1366 H_PUT_32 (input_bfd
, r_symndx
, ext_rel
->r_symndx
);
1371 /* Relocate a section while linking an Alpha ECOFF file. This is
1372 quite similar to get_relocated_section_contents. Perhaps they
1373 could be combined somehow. */
1376 alpha_relocate_section (bfd
*output_bfd
,
1377 struct bfd_link_info
*info
,
1379 asection
*input_section
,
1381 void * external_relocs
)
1383 asection
**symndx_to_section
, *lita_sec
;
1384 struct ecoff_link_hash_entry
**sym_hashes
;
1387 bfd_vma stack
[RELOC_STACKSIZE
];
1389 struct external_reloc
*ext_rel
;
1390 struct external_reloc
*ext_rel_end
;
1393 /* We keep a table mapping the symndx found in an internal reloc to
1394 the appropriate section. This is faster than looking up the
1395 section by name each time. */
1396 symndx_to_section
= ecoff_data (input_bfd
)->symndx_to_section
;
1397 if (symndx_to_section
== (asection
**) NULL
)
1399 amt
= NUM_RELOC_SECTIONS
* sizeof (asection
*);
1400 symndx_to_section
= (asection
**) bfd_alloc (input_bfd
, amt
);
1401 if (!symndx_to_section
)
1404 symndx_to_section
[RELOC_SECTION_NONE
] = NULL
;
1405 symndx_to_section
[RELOC_SECTION_TEXT
] =
1406 bfd_get_section_by_name (input_bfd
, ".text");
1407 symndx_to_section
[RELOC_SECTION_RDATA
] =
1408 bfd_get_section_by_name (input_bfd
, ".rdata");
1409 symndx_to_section
[RELOC_SECTION_DATA
] =
1410 bfd_get_section_by_name (input_bfd
, ".data");
1411 symndx_to_section
[RELOC_SECTION_SDATA
] =
1412 bfd_get_section_by_name (input_bfd
, ".sdata");
1413 symndx_to_section
[RELOC_SECTION_SBSS
] =
1414 bfd_get_section_by_name (input_bfd
, ".sbss");
1415 symndx_to_section
[RELOC_SECTION_BSS
] =
1416 bfd_get_section_by_name (input_bfd
, ".bss");
1417 symndx_to_section
[RELOC_SECTION_INIT
] =
1418 bfd_get_section_by_name (input_bfd
, ".init");
1419 symndx_to_section
[RELOC_SECTION_LIT8
] =
1420 bfd_get_section_by_name (input_bfd
, ".lit8");
1421 symndx_to_section
[RELOC_SECTION_LIT4
] =
1422 bfd_get_section_by_name (input_bfd
, ".lit4");
1423 symndx_to_section
[RELOC_SECTION_XDATA
] =
1424 bfd_get_section_by_name (input_bfd
, ".xdata");
1425 symndx_to_section
[RELOC_SECTION_PDATA
] =
1426 bfd_get_section_by_name (input_bfd
, ".pdata");
1427 symndx_to_section
[RELOC_SECTION_FINI
] =
1428 bfd_get_section_by_name (input_bfd
, ".fini");
1429 symndx_to_section
[RELOC_SECTION_LITA
] =
1430 bfd_get_section_by_name (input_bfd
, ".lita");
1431 symndx_to_section
[RELOC_SECTION_ABS
] = bfd_abs_section_ptr
;
1432 symndx_to_section
[RELOC_SECTION_RCONST
] =
1433 bfd_get_section_by_name (input_bfd
, ".rconst");
1435 ecoff_data (input_bfd
)->symndx_to_section
= symndx_to_section
;
1438 sym_hashes
= ecoff_data (input_bfd
)->sym_hashes
;
1440 /* On the Alpha, the .lita section must be addressable by the global
1441 pointer. To support large programs, we need to allow multiple
1442 global pointers. This works as long as each input .lita section
1443 is <64KB big. This implies that when producing relocatable
1444 output, the .lita section is limited to 64KB. . */
1446 lita_sec
= symndx_to_section
[RELOC_SECTION_LITA
];
1447 gp
= _bfd_get_gp_value (output_bfd
);
1448 if (! bfd_link_relocatable (info
) && lita_sec
!= NULL
)
1450 struct ecoff_section_tdata
*lita_sec_data
;
1452 /* Make sure we have a section data structure to which we can
1453 hang on to the gp value we pick for the section. */
1454 lita_sec_data
= ecoff_section_data (input_bfd
, lita_sec
);
1455 if (lita_sec_data
== NULL
)
1457 amt
= sizeof (struct ecoff_section_tdata
);
1458 lita_sec_data
= ((struct ecoff_section_tdata
*)
1459 bfd_zalloc (input_bfd
, amt
));
1460 lita_sec
->used_by_bfd
= lita_sec_data
;
1463 if (lita_sec_data
->gp
!= 0)
1465 /* If we already assigned a gp to this section, we better
1466 stick with that value. */
1467 gp
= lita_sec_data
->gp
;
1472 bfd_size_type lita_size
;
1474 lita_vma
= lita_sec
->output_offset
+ lita_sec
->output_section
->vma
;
1475 lita_size
= lita_sec
->size
;
1478 || lita_vma
< gp
- 0x8000
1479 || lita_vma
+ lita_size
>= gp
+ 0x8000)
1481 /* Either gp hasn't been set at all or the current gp
1482 cannot address this .lita section. In both cases we
1483 reset the gp to point into the "middle" of the
1484 current input .lita section. */
1485 if (gp
&& !ecoff_data (output_bfd
)->issued_multiple_gp_warning
)
1487 (*info
->callbacks
->warning
) (info
,
1488 _("using multiple gp values"),
1489 (char *) NULL
, output_bfd
,
1490 (asection
*) NULL
, (bfd_vma
) 0);
1491 ecoff_data (output_bfd
)->issued_multiple_gp_warning
= true;
1493 if (lita_vma
< gp
- 0x8000)
1494 gp
= lita_vma
+ lita_size
- 0x8000;
1496 gp
= lita_vma
+ 0x8000;
1500 lita_sec_data
->gp
= gp
;
1503 _bfd_set_gp_value (output_bfd
, gp
);
1506 gp_undefined
= (gp
== 0);
1508 BFD_ASSERT (bfd_header_little_endian (output_bfd
));
1509 BFD_ASSERT (bfd_header_little_endian (input_bfd
));
1511 ext_rel
= (struct external_reloc
*) external_relocs
;
1512 ext_rel_end
= ext_rel
+ input_section
->reloc_count
;
1513 for (; ext_rel
< ext_rel_end
; ext_rel
++)
1516 unsigned long r_symndx
;
1526 r_vaddr
= H_GET_64 (input_bfd
, ext_rel
->r_vaddr
);
1527 r_symndx
= H_GET_32 (input_bfd
, ext_rel
->r_symndx
);
1529 r_type
= ((ext_rel
->r_bits
[0] & RELOC_BITS0_TYPE_LITTLE
)
1530 >> RELOC_BITS0_TYPE_SH_LITTLE
);
1531 r_extern
= (ext_rel
->r_bits
[1] & RELOC_BITS1_EXTERN_LITTLE
) != 0;
1532 r_offset
= ((ext_rel
->r_bits
[1] & RELOC_BITS1_OFFSET_LITTLE
)
1533 >> RELOC_BITS1_OFFSET_SH_LITTLE
);
1534 /* Ignored the reserved bits. */
1535 r_size
= ((ext_rel
->r_bits
[3] & RELOC_BITS3_SIZE_LITTLE
)
1536 >> RELOC_BITS3_SIZE_SH_LITTLE
);
1539 adjust_addrp
= true;
1545 case ALPHA_R_GPRELHIGH
:
1546 _bfd_error_handler (_("%pB: %s unsupported"),
1547 input_bfd
, "ALPHA_R_GPRELHIGH");
1548 bfd_set_error (bfd_error_bad_value
);
1551 case ALPHA_R_GPRELLOW
:
1552 _bfd_error_handler (_("%pB: %s unsupported"),
1553 input_bfd
, "ALPHA_R_GPRELLOW");
1554 bfd_set_error (bfd_error_bad_value
);
1558 /* xgettext:c-format */
1559 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1560 input_bfd
, (int) r_type
);
1561 bfd_set_error (bfd_error_bad_value
);
1564 case ALPHA_R_IGNORE
:
1565 /* This reloc appears after a GPDISP reloc. On earlier
1566 versions of OSF/1, It marked the position of the second
1567 instruction to be altered by the GPDISP reloc, but it is
1568 not otherwise used for anything. For some reason, the
1569 address of the relocation does not appear to include the
1570 section VMA, unlike the other relocation types. */
1571 if (bfd_link_relocatable (info
))
1572 H_PUT_64 (input_bfd
, input_section
->output_offset
+ r_vaddr
,
1574 adjust_addrp
= false;
1577 case ALPHA_R_REFLONG
:
1578 case ALPHA_R_REFQUAD
:
1583 case ALPHA_R_BRADDR
:
1584 case ALPHA_R_SREL16
:
1585 case ALPHA_R_SREL32
:
1586 case ALPHA_R_SREL64
:
1588 addend
+= - (r_vaddr
+ 4);
1592 case ALPHA_R_GPREL32
:
1593 /* This relocation is used in a switch table. It is a 32
1594 bit offset from the current GP value. We must adjust it
1595 by the different between the original GP value and the
1596 current GP value. */
1598 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1602 case ALPHA_R_LITERAL
:
1603 /* This is a reference to a literal value, generally
1604 (always?) in the .lita section. This is a 16 bit GP
1605 relative relocation. Sometimes the subsequent reloc is a
1606 LITUSE reloc, which indicates how this reloc is used.
1607 This sometimes permits rewriting the two instructions
1608 referred to by the LITERAL and the LITUSE into different
1609 instructions which do not refer to .lita. This can save
1610 a memory reference, and permits removing a value from
1611 .lita thus saving GP relative space.
1613 We do not these optimizations. To do them we would need
1614 to arrange to link the .lita section first, so that by
1615 the time we got here we would know the final values to
1616 use. This would not be particularly difficult, but it is
1617 not currently implemented. */
1619 /* I believe that the LITERAL reloc will only apply to a ldq
1620 or ldl instruction, so check my assumption. */
1624 insn
= bfd_get_32 (input_bfd
,
1625 contents
+ r_vaddr
- input_section
->vma
);
1626 BFD_ASSERT (((insn
>> 26) & 0x3f) == 0x29
1627 || ((insn
>> 26) & 0x3f) == 0x28);
1631 addend
= ecoff_data (input_bfd
)->gp
- gp
;
1635 case ALPHA_R_LITUSE
:
1636 /* See ALPHA_R_LITERAL above for the uses of this reloc. It
1637 does not cause anything to happen, itself. */
1640 case ALPHA_R_GPDISP
:
1641 /* This marks the ldah of an ldah/lda pair which loads the
1642 gp register with the difference of the gp value and the
1643 current location. The second of the pair is r_symndx
1644 bytes ahead. It used to be marked with an ALPHA_R_IGNORE
1645 reloc, but OSF/1 3.2 no longer does that. */
1647 unsigned long insn1
, insn2
;
1649 /* Get the two instructions. */
1650 insn1
= bfd_get_32 (input_bfd
,
1651 contents
+ r_vaddr
- input_section
->vma
);
1652 insn2
= bfd_get_32 (input_bfd
,
1655 - input_section
->vma
1658 BFD_ASSERT (((insn1
>> 26) & 0x3f) == 0x09); /* ldah */
1659 BFD_ASSERT (((insn2
>> 26) & 0x3f) == 0x08); /* lda */
1661 /* Get the existing addend. We must account for the sign
1662 extension done by lda and ldah. */
1663 addend
= ((insn1
& 0xffff) << 16) + (insn2
& 0xffff);
1666 /* This is addend -= 0x100000000 without causing an
1667 integer overflow on a 32 bit host. */
1668 addend
-= 0x80000000;
1669 addend
-= 0x80000000;
1674 /* The existing addend includes the difference between the
1675 gp of the input BFD and the address in the input BFD.
1676 We want to change this to the difference between the
1677 final GP and the final address. */
1679 - ecoff_data (input_bfd
)->gp
1680 + input_section
->vma
1681 - (input_section
->output_section
->vma
1682 + input_section
->output_offset
));
1684 /* Change the instructions, accounting for the sign
1685 extension, and write them out. */
1686 if (addend
& 0x8000)
1688 insn1
= (insn1
& 0xffff0000) | ((addend
>> 16) & 0xffff);
1689 insn2
= (insn2
& 0xffff0000) | (addend
& 0xffff);
1691 bfd_put_32 (input_bfd
, (bfd_vma
) insn1
,
1692 contents
+ r_vaddr
- input_section
->vma
);
1693 bfd_put_32 (input_bfd
, (bfd_vma
) insn2
,
1694 contents
+ r_vaddr
- input_section
->vma
+ r_symndx
);
1700 case ALPHA_R_OP_PUSH
:
1701 case ALPHA_R_OP_PSUB
:
1702 case ALPHA_R_OP_PRSHIFT
:
1703 /* Manipulate values on the reloc evaluation stack. The
1704 r_vaddr field is not an address in input_section, it is
1705 the current value (including any addend) of the object
1711 s
= symndx_to_section
[r_symndx
];
1712 if (s
== (asection
*) NULL
)
1714 addend
= s
->output_section
->vma
+ s
->output_offset
- s
->vma
;
1718 struct ecoff_link_hash_entry
*h
;
1720 h
= sym_hashes
[r_symndx
];
1721 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
1724 if (! bfd_link_relocatable (info
))
1726 if (h
->root
.type
== bfd_link_hash_defined
1727 || h
->root
.type
== bfd_link_hash_defweak
)
1728 addend
= (h
->root
.u
.def
.value
1729 + h
->root
.u
.def
.section
->output_section
->vma
1730 + h
->root
.u
.def
.section
->output_offset
);
1733 /* Note that we pass the address as 0, since we
1734 do not have a meaningful number for the
1735 location within the section that is being
1737 (*info
->callbacks
->undefined_symbol
)
1738 (info
, h
->root
.root
.string
, input_bfd
,
1739 input_section
, (bfd_vma
) 0, true);
1745 if (h
->root
.type
!= bfd_link_hash_defined
1746 && h
->root
.type
!= bfd_link_hash_defweak
1749 /* This symbol is not being written out. Pass
1750 the address as 0, as with undefined_symbol,
1752 (*info
->callbacks
->unattached_reloc
)
1753 (info
, h
->root
.root
.string
,
1754 input_bfd
, input_section
, (bfd_vma
) 0);
1757 addend
= alpha_convert_external_reloc (output_bfd
, info
,
1765 if (bfd_link_relocatable (info
))
1767 /* Adjust r_vaddr by the addend. */
1768 H_PUT_64 (input_bfd
, addend
, ext_rel
->r_vaddr
);
1774 case ALPHA_R_OP_PUSH
:
1775 if (tos
>= RELOC_STACKSIZE
)
1777 stack
[tos
++] = addend
;
1780 case ALPHA_R_OP_PSUB
:
1783 stack
[tos
- 1] -= addend
;
1786 case ALPHA_R_OP_PRSHIFT
:
1789 stack
[tos
- 1] >>= addend
;
1794 adjust_addrp
= false;
1797 case ALPHA_R_OP_STORE
:
1798 /* Store a value from the reloc stack into a bitfield. If
1799 we are generating relocatable output, all we do is
1800 adjust the address of the reloc. */
1801 if (! bfd_link_relocatable (info
))
1809 /* Get the relocation mask. The separate steps and the
1810 casts to bfd_vma are attempts to avoid a bug in the
1811 Alpha OSF 1.3 C compiler. See reloc.c for more
1814 mask
<<= (bfd_vma
) r_size
;
1817 /* FIXME: I don't know what kind of overflow checking,
1818 if any, should be done here. */
1819 val
= bfd_get_64 (input_bfd
,
1820 contents
+ r_vaddr
- input_section
->vma
);
1821 val
&=~ mask
<< (bfd_vma
) r_offset
;
1822 val
|= (stack
[--tos
] & mask
) << (bfd_vma
) r_offset
;
1823 bfd_put_64 (input_bfd
, val
,
1824 contents
+ r_vaddr
- input_section
->vma
);
1828 case ALPHA_R_GPVALUE
:
1829 /* I really don't know if this does the right thing. */
1830 gp
= ecoff_data (input_bfd
)->gp
+ r_symndx
;
1831 gp_undefined
= false;
1837 reloc_howto_type
*howto
;
1838 struct ecoff_link_hash_entry
*h
= NULL
;
1841 bfd_reloc_status_type r
;
1843 /* Perform a relocation. */
1845 howto
= &alpha_howto_table
[r_type
];
1849 h
= sym_hashes
[r_symndx
];
1850 /* If h is NULL, that means that there is a reloc
1851 against an external symbol which we thought was just
1852 a debugging symbol. This should not happen. */
1853 if (h
== (struct ecoff_link_hash_entry
*) NULL
)
1858 if (r_symndx
>= NUM_RELOC_SECTIONS
)
1861 s
= symndx_to_section
[r_symndx
];
1863 if (s
== (asection
*) NULL
)
1867 if (bfd_link_relocatable (info
))
1869 /* We are generating relocatable output, and must
1870 convert the existing reloc. */
1873 if (h
->root
.type
!= bfd_link_hash_defined
1874 && h
->root
.type
!= bfd_link_hash_defweak
1877 /* This symbol is not being written out. */
1878 (*info
->callbacks
->unattached_reloc
)
1879 (info
, h
->root
.root
.string
, input_bfd
,
1880 input_section
, r_vaddr
- input_section
->vma
);
1883 relocation
= alpha_convert_external_reloc (output_bfd
,
1891 /* This is a relocation against a section. Adjust
1892 the value by the amount the section moved. */
1893 relocation
= (s
->output_section
->vma
1898 /* If this is PC relative, the existing object file
1899 appears to already have the reloc worked out. We
1900 must subtract out the old value and add in the new
1902 if (howto
->pc_relative
)
1903 relocation
-= (input_section
->output_section
->vma
1904 + input_section
->output_offset
1905 - input_section
->vma
);
1907 /* Put in any addend. */
1908 relocation
+= addend
;
1910 /* Adjust the contents. */
1911 r
= _bfd_relocate_contents (howto
, input_bfd
, relocation
,
1914 - input_section
->vma
));
1918 /* We are producing a final executable. */
1921 /* This is a reloc against a symbol. */
1922 if (h
->root
.type
== bfd_link_hash_defined
1923 || h
->root
.type
== bfd_link_hash_defweak
)
1927 hsec
= h
->root
.u
.def
.section
;
1928 relocation
= (h
->root
.u
.def
.value
1929 + hsec
->output_section
->vma
1930 + hsec
->output_offset
);
1934 (*info
->callbacks
->undefined_symbol
)
1935 (info
, h
->root
.root
.string
, input_bfd
, input_section
,
1936 r_vaddr
- input_section
->vma
, true);
1942 /* This is a reloc against a section. */
1943 relocation
= (s
->output_section
->vma
1947 /* Adjust a PC relative relocation by removing the
1948 reference to the original source section. */
1949 if (howto
->pc_relative
)
1950 relocation
+= input_section
->vma
;
1953 r
= _bfd_final_link_relocate (howto
,
1957 r_vaddr
- input_section
->vma
,
1962 if (r
!= bfd_reloc_ok
)
1967 case bfd_reloc_outofrange
:
1969 case bfd_reloc_overflow
:
1974 name
= sym_hashes
[r_symndx
]->root
.root
.string
;
1976 name
= bfd_section_name (symndx_to_section
[r_symndx
]);
1977 (*info
->callbacks
->reloc_overflow
)
1978 (info
, NULL
, name
, alpha_howto_table
[r_type
].name
,
1979 (bfd_vma
) 0, input_bfd
, input_section
,
1980 r_vaddr
- input_section
->vma
);
1987 if (bfd_link_relocatable (info
) && adjust_addrp
)
1989 /* Change the address of the relocation. */
1990 H_PUT_64 (input_bfd
,
1991 (input_section
->output_section
->vma
1992 + input_section
->output_offset
1993 - input_section
->vma
1998 if (gp_usedp
&& gp_undefined
)
2000 (*info
->callbacks
->reloc_dangerous
)
2001 (info
, _("GP relative relocation used when GP not defined"),
2002 input_bfd
, input_section
, r_vaddr
- input_section
->vma
);
2003 /* Only give the error once per link. */
2005 _bfd_set_gp_value (output_bfd
, gp
);
2006 gp_undefined
= false;
2016 /* Do final adjustments to the filehdr and the aouthdr. This routine
2017 sets the dynamic bits in the file header. */
2020 alpha_adjust_headers (bfd
*abfd
,
2021 struct internal_filehdr
*fhdr
,
2022 struct internal_aouthdr
*ahdr ATTRIBUTE_UNUSED
)
2024 if ((abfd
->flags
& (DYNAMIC
| EXEC_P
)) == (DYNAMIC
| EXEC_P
))
2025 fhdr
->f_flags
|= F_ALPHA_CALL_SHARED
;
2026 else if ((abfd
->flags
& DYNAMIC
) != 0)
2027 fhdr
->f_flags
|= F_ALPHA_SHARABLE
;
2031 /* Archive handling. In OSF/1 (or Digital Unix) v3.2, Digital
2032 introduced archive packing, in which the elements in an archive are
2033 optionally compressed using a simple dictionary scheme. We know
2034 how to read such archives, but we don't write them. */
2036 #define alpha_ecoff_slurp_armap _bfd_ecoff_slurp_armap
2037 #define alpha_ecoff_slurp_extended_name_table \
2038 _bfd_ecoff_slurp_extended_name_table
2039 #define alpha_ecoff_construct_extended_name_table \
2040 _bfd_ecoff_construct_extended_name_table
2041 #define alpha_ecoff_truncate_arname _bfd_ecoff_truncate_arname
2042 #define alpha_ecoff_write_armap _bfd_ecoff_write_armap
2043 #define alpha_ecoff_write_ar_hdr _bfd_generic_write_ar_hdr
2044 #define alpha_ecoff_generic_stat_arch_elt _bfd_ecoff_generic_stat_arch_elt
2045 #define alpha_ecoff_update_armap_timestamp _bfd_ecoff_update_armap_timestamp
2047 /* A compressed file uses this instead of ARFMAG. */
2049 #define ARFZMAG "Z\012"
2051 /* Read an archive header. This is like the standard routine, but it
2052 also accepts ARFZMAG. */
2055 alpha_ecoff_read_ar_hdr (bfd
*abfd
)
2057 struct areltdata
*ret
;
2060 ret
= (struct areltdata
*) _bfd_generic_read_ar_hdr_mag (abfd
, ARFZMAG
);
2064 h
= (struct ar_hdr
*) ret
->arch_header
;
2065 if (strncmp (h
->ar_fmag
, ARFZMAG
, 2) == 0)
2069 /* This is a compressed file. We must set the size correctly.
2070 The size is the eight bytes after the dummy file header. */
2071 if (bfd_seek (abfd
, FILHSZ
, SEEK_CUR
) != 0
2072 || bfd_read (ab
, 8, abfd
) != 8
2073 || bfd_seek (abfd
, -(FILHSZ
+ 8), SEEK_CUR
) != 0)
2079 ret
->parsed_size
= H_GET_64 (abfd
, ab
);
2085 /* Get an archive element at a specified file position. This is where
2086 we uncompress the archive element if necessary. */
2089 alpha_ecoff_get_elt_at_filepos (bfd
*archive
, file_ptr filepos
,
2090 struct bfd_link_info
*info
)
2093 struct areltdata
*tdata
;
2098 struct bfd_in_memory
*bim
;
2102 nbfd
= _bfd_get_elt_at_filepos (archive
, filepos
, info
);
2106 if ((nbfd
->flags
& BFD_IN_MEMORY
) != 0)
2108 /* We have already expanded this BFD. */
2112 tdata
= (struct areltdata
*) nbfd
->arelt_data
;
2113 hdr
= (struct ar_hdr
*) tdata
->arch_header
;
2114 if (strncmp (hdr
->ar_fmag
, ARFZMAG
, 2) != 0)
2117 /* We must uncompress this element. We do this by copying it into a
2118 memory buffer, and making bfd_read and bfd_seek use that buffer.
2119 This can use a lot of memory, but it's simpler than getting a
2120 temporary file, making that work with the file descriptor caching
2121 code, and making sure that it is deleted at all appropriate
2122 times. It can be changed if it ever becomes important. */
2124 /* The compressed file starts with a dummy ECOFF file header. */
2125 if (bfd_seek (nbfd
, FILHSZ
, SEEK_SET
) != 0)
2128 /* The next eight bytes are the real file size. */
2129 if (bfd_read (ab
, 8, nbfd
) != 8)
2131 size
= H_GET_64 (nbfd
, ab
);
2133 /* The decompression algorithm will at most expand by eight times. */
2134 filesize
= bfd_get_file_size (archive
);
2135 if (filesize
!= 0 && size
/ 8 > filesize
)
2137 bfd_set_error (bfd_error_malformed_archive
);
2144 bfd_byte dict
[4096];
2148 buf
= (bfd_byte
*) bfd_malloc (size
);
2155 /* I don't know what the next eight bytes are for. */
2156 if (bfd_read (ab
, 8, nbfd
) != 8)
2159 /* This is the uncompression algorithm. It's a simple
2160 dictionary based scheme in which each character is predicted
2161 by a hash of the previous three characters. A control byte
2162 indicates whether the character is predicted or whether it
2163 appears in the input stream; each control byte manages the
2164 next eight bytes in the output stream. */
2165 memset (dict
, 0, sizeof dict
);
2167 while (bfd_read (&b
, 1, nbfd
) == 1)
2171 for (i
= 0; i
< 8; i
++, b
>>= 1)
2179 if (bfd_read (&n
, 1, nbfd
) != 1)
2192 h
&= sizeof dict
- 1;
2200 /* Now the uncompressed file contents are in buf. */
2201 bim
= ((struct bfd_in_memory
*)
2202 bfd_malloc ((bfd_size_type
) sizeof (struct bfd_in_memory
)));
2208 nbfd
->mtime_set
= true;
2209 nbfd
->mtime
= strtol (hdr
->ar_date
, (char **) NULL
, 10);
2211 nbfd
->flags
|= BFD_IN_MEMORY
;
2212 nbfd
->iostream
= bim
;
2213 nbfd
->iovec
= &_bfd_memory_iovec
;
2216 BFD_ASSERT (! nbfd
->cacheable
);
2227 /* Open the next archived file. */
2230 alpha_ecoff_openr_next_archived_file (bfd
*archive
, bfd
*last_file
)
2232 ufile_ptr filestart
;
2234 if (last_file
== NULL
)
2235 filestart
= bfd_ardata (archive
)->first_file_filepos
;
2238 struct areltdata
*t
;
2242 /* We can't use arelt_size here, because that uses parsed_size,
2243 which is the uncompressed size. We need the compressed size. */
2244 t
= (struct areltdata
*) last_file
->arelt_data
;
2245 h
= (struct ar_hdr
*) t
->arch_header
;
2246 size
= strtol (h
->ar_size
, (char **) NULL
, 10);
2248 /* Pad to an even boundary...
2249 Note that last_file->origin can be odd in the case of
2250 BSD-4.4-style element with a long odd size. */
2251 filestart
= last_file
->proxy_origin
+ size
;
2252 filestart
+= filestart
% 2;
2253 if (filestart
< last_file
->proxy_origin
)
2255 /* Prevent looping. See PR19256. */
2256 bfd_set_error (bfd_error_malformed_archive
);
2261 return alpha_ecoff_get_elt_at_filepos (archive
, filestart
, NULL
);
2264 /* Open the archive file given an index into the armap. */
2267 alpha_ecoff_get_elt_at_index (bfd
*abfd
, symindex sym_index
)
2271 entry
= bfd_ardata (abfd
)->symdefs
+ sym_index
;
2272 return alpha_ecoff_get_elt_at_filepos (abfd
, entry
->file_offset
,
2277 alpha_ecoff_swap_coff_aux_in (bfd
*abfd ATTRIBUTE_UNUSED
,
2278 void *ext1 ATTRIBUTE_UNUSED
,
2279 int type ATTRIBUTE_UNUSED
,
2280 int in_class ATTRIBUTE_UNUSED
,
2281 int indx ATTRIBUTE_UNUSED
,
2282 int numaux ATTRIBUTE_UNUSED
,
2283 void *in1 ATTRIBUTE_UNUSED
)
2288 alpha_ecoff_swap_coff_sym_in (bfd
*abfd ATTRIBUTE_UNUSED
,
2289 void *ext1 ATTRIBUTE_UNUSED
,
2290 void *in1 ATTRIBUTE_UNUSED
)
2295 alpha_ecoff_swap_coff_lineno_in (bfd
*abfd ATTRIBUTE_UNUSED
,
2296 void *ext1 ATTRIBUTE_UNUSED
,
2297 void *in1 ATTRIBUTE_UNUSED
)
2302 alpha_ecoff_swap_coff_aux_out (bfd
*abfd ATTRIBUTE_UNUSED
,
2303 void *inp ATTRIBUTE_UNUSED
,
2304 int type ATTRIBUTE_UNUSED
,
2305 int in_class ATTRIBUTE_UNUSED
,
2306 int indx ATTRIBUTE_UNUSED
,
2307 int numaux ATTRIBUTE_UNUSED
,
2308 void *extp ATTRIBUTE_UNUSED
)
2314 alpha_ecoff_swap_coff_sym_out (bfd
*abfd ATTRIBUTE_UNUSED
,
2315 void *inp ATTRIBUTE_UNUSED
,
2316 void *extp ATTRIBUTE_UNUSED
)
2322 alpha_ecoff_swap_coff_lineno_out (bfd
*abfd ATTRIBUTE_UNUSED
,
2323 void *inp ATTRIBUTE_UNUSED
,
2324 void *extp ATTRIBUTE_UNUSED
)
2330 alpha_ecoff_swap_coff_reloc_out (bfd
*abfd ATTRIBUTE_UNUSED
,
2331 void *inp ATTRIBUTE_UNUSED
,
2332 void *extp ATTRIBUTE_UNUSED
)
2337 /* This is the ECOFF backend structure. The backend field of the
2338 target vector points to this. */
2340 static const struct ecoff_backend_data alpha_ecoff_backend_data
=
2342 /* COFF backend structure. */
2344 alpha_ecoff_swap_coff_aux_in
, alpha_ecoff_swap_coff_sym_in
,
2345 alpha_ecoff_swap_coff_lineno_in
, alpha_ecoff_swap_coff_aux_out
,
2346 alpha_ecoff_swap_coff_sym_out
, alpha_ecoff_swap_coff_lineno_out
,
2347 alpha_ecoff_swap_coff_reloc_out
,
2348 alpha_ecoff_swap_filehdr_out
, alpha_ecoff_swap_aouthdr_out
,
2349 alpha_ecoff_swap_scnhdr_out
,
2350 FILHSZ
, AOUTSZ
, SCNHSZ
, 0, 0, 0, 0, FILNMLEN
, true,
2351 ECOFF_NO_LONG_SECTION_NAMES
, 4, false, 2, 32768,
2352 alpha_ecoff_swap_filehdr_in
, alpha_ecoff_swap_aouthdr_in
,
2353 alpha_ecoff_swap_scnhdr_in
, NULL
,
2354 alpha_ecoff_bad_format_hook
, _bfd_ecoff_set_arch_mach_hook
,
2355 alpha_ecoff_mkobject_hook
, _bfd_ecoff_styp_to_sec_flags
,
2356 _bfd_ecoff_set_alignment_hook
, _bfd_ecoff_slurp_symbol_table
,
2357 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
2358 NULL
, NULL
, NULL
, NULL
2360 /* Supported architecture. */
2362 /* Initial portion of armap string. */
2364 /* The page boundary used to align sections in a demand-paged
2365 executable file. E.g., 0x1000. */
2367 /* TRUE if the .rdata section is part of the text segment, as on the
2368 Alpha. FALSE if .rdata is part of the data segment, as on the
2371 /* Bitsize of constructor entries. */
2373 /* Reloc to use for constructor entries. */
2374 &alpha_howto_table
[ALPHA_R_REFQUAD
],
2376 /* Symbol table magic number. */
2378 /* Alignment of debugging information. E.g., 4. */
2380 /* Sizes of external symbolic information. */
2381 sizeof (struct hdr_ext
),
2382 sizeof (struct dnr_ext
),
2383 sizeof (struct pdr_ext
),
2384 sizeof (struct sym_ext
),
2385 sizeof (struct opt_ext
),
2386 sizeof (struct fdr_ext
),
2387 sizeof (struct rfd_ext
),
2388 sizeof (struct ext_ext
),
2389 /* Functions to swap in external symbolic data. */
2398 _bfd_ecoff_swap_tir_in
,
2399 _bfd_ecoff_swap_rndx_in
,
2400 /* Functions to swap out external symbolic data. */
2409 _bfd_ecoff_swap_tir_out
,
2410 _bfd_ecoff_swap_rndx_out
,
2411 /* Function to read in symbolic data. */
2412 _bfd_ecoff_slurp_symbolic_info
2414 /* External reloc size. */
2416 /* Reloc swapping functions. */
2417 alpha_ecoff_swap_reloc_in
,
2418 alpha_ecoff_swap_reloc_out
,
2419 /* Backend reloc tweaking. */
2420 alpha_adjust_reloc_in
,
2421 alpha_adjust_reloc_out
,
2422 /* Relocate section contents while linking. */
2423 alpha_relocate_section
,
2424 /* Do final adjustments to filehdr and aouthdr. */
2425 alpha_adjust_headers
,
2426 /* Read an element from an archive at a given file position. */
2427 alpha_ecoff_get_elt_at_filepos
2430 /* Looking up a reloc type is Alpha specific. */
2431 #define _bfd_ecoff_bfd_reloc_type_lookup alpha_bfd_reloc_type_lookup
2432 #define _bfd_ecoff_bfd_reloc_name_lookup \
2433 alpha_bfd_reloc_name_lookup
2435 /* So is getting relocated section contents. */
2436 #define _bfd_ecoff_bfd_get_relocated_section_contents \
2437 alpha_ecoff_get_relocated_section_contents
2439 /* Handling file windows is generic. */
2440 #define _bfd_ecoff_get_section_contents_in_window \
2441 _bfd_generic_get_section_contents_in_window
2443 /* Input section flag lookup is generic. */
2444 #define _bfd_ecoff_bfd_lookup_section_flags bfd_generic_lookup_section_flags
2446 /* Relaxing sections is generic. */
2447 #define _bfd_ecoff_bfd_relax_section bfd_generic_relax_section
2448 #define _bfd_ecoff_bfd_gc_sections bfd_generic_gc_sections
2449 #define _bfd_ecoff_bfd_merge_sections bfd_generic_merge_sections
2450 #define _bfd_ecoff_bfd_is_group_section bfd_generic_is_group_section
2451 #define _bfd_ecoff_bfd_group_name bfd_generic_group_name
2452 #define _bfd_ecoff_bfd_discard_group bfd_generic_discard_group
2453 #define _bfd_ecoff_section_already_linked \
2454 _bfd_coff_section_already_linked
2455 #define _bfd_ecoff_bfd_define_common_symbol bfd_generic_define_common_symbol
2456 #define _bfd_ecoff_bfd_link_hide_symbol _bfd_generic_link_hide_symbol
2457 #define _bfd_ecoff_bfd_define_start_stop bfd_generic_define_start_stop
2458 #define _bfd_ecoff_bfd_link_check_relocs _bfd_generic_link_check_relocs
2460 /* Installing internal relocations in a section is also generic. */
2461 #define _bfd_ecoff_set_reloc _bfd_generic_set_reloc
2463 const bfd_target alpha_ecoff_le_vec
=
2465 "ecoff-littlealpha", /* name */
2466 bfd_target_ecoff_flavour
,
2467 BFD_ENDIAN_LITTLE
, /* data byte order is little */
2468 BFD_ENDIAN_LITTLE
, /* header byte order is little */
2470 (HAS_RELOC
| EXEC_P
/* object flags */
2471 | HAS_LINENO
| HAS_DEBUG
2472 | HAS_SYMS
| HAS_LOCALS
| DYNAMIC
| WP_TEXT
| D_PAGED
),
2474 (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
| SEC_CODE
2475 | SEC_DATA
| SEC_SMALL_DATA
),
2476 0, /* leading underscore */
2477 ' ', /* ar_pad_char */
2478 15, /* ar_max_namelen */
2479 0, /* match priority. */
2480 TARGET_KEEP_UNUSED_SECTION_SYMBOLS
, /* keep unused section symbols. */
2481 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2482 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2483 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* data */
2484 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2485 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2486 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
, /* hdrs */
2488 { /* bfd_check_format */
2490 alpha_ecoff_object_p
,
2491 bfd_generic_archive_p
,
2494 { /* bfd_set_format */
2495 _bfd_bool_bfd_false_error
,
2496 _bfd_ecoff_mkobject
,
2497 _bfd_generic_mkarchive
,
2498 _bfd_bool_bfd_false_error
2500 { /* bfd_write_contents */
2501 _bfd_bool_bfd_false_error
,
2502 _bfd_ecoff_write_object_contents
,
2503 _bfd_write_archive_contents
,
2504 _bfd_bool_bfd_false_error
2507 BFD_JUMP_TABLE_GENERIC (_bfd_ecoff
),
2508 BFD_JUMP_TABLE_COPY (_bfd_ecoff
),
2509 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
2510 BFD_JUMP_TABLE_ARCHIVE (alpha_ecoff
),
2511 BFD_JUMP_TABLE_SYMBOLS (_bfd_ecoff
),
2512 BFD_JUMP_TABLE_RELOCS (_bfd_ecoff
),
2513 BFD_JUMP_TABLE_WRITE (_bfd_ecoff
),
2514 BFD_JUMP_TABLE_LINK (_bfd_ecoff
),
2515 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),
2519 &alpha_ecoff_backend_data